@iowarp/clio-coder 0.3.0 → 0.3.1

package/src/tools/dispatch.ts

@@ -0,0 +1,3338 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { Type } from "typebox";
+import { BusChannels } from "../core/bus-events.js";
+import type { SafeEventBus } from "../core/event-bus.js";
+import { ToolNames } from "../core/tool-names.js";
+import { clioStateDir } from "../core/xdg.js";
+import type { AgentSpec } from "../domains/agents/spec.js";
+import { closeAgentLedger, openAgentLedger, renderAgentLedgerBoard } from "../domains/dispatch/agent-ledger-store.js";
+import type { DetachedBatchRun } from "../domains/dispatch/batch-store.js";
+import type {
+	AbortReason,
+	DispatchContract,
+	DispatchPlanTaskResolution,
+	DispatchRequest,
+} from "../domains/dispatch/contract.js";
+import { durableAssistantTextFromEvent } from "../domains/dispatch/event-pump.js";
+import { compileExecutionPlan, type ExecutionPlan, requireAgentSteps } from "../domains/dispatch/execution-plan.js";
+import {
+	type AgentRoleFactsResolver,
+	gateDeciderAgentId,
+	gateRouteCorrelation,
+	type RouteCorrelationFacts,
+} from "../domains/dispatch/execution-role.js";
+import {
+	decideReviewGate,
+	finalizePendingGateDecision,
+	type GateDecisionArtifact,
+	type GateDecisionCorrelation,
+	type GateDecisionDraft,
+	materializePendingGateDecision,
+	type PendingGateDecisionHandle,
+	parseCompeteGateResult,
+	preflightPendingGateDecisionMaterialization,
+	preparePendingGateDecisionRecovery,
+	readGateDecisionArtifacts,
+	resolvePendingGateDecision,
+	stagePendingGateDecision,
+	stagePendingGateOutput,
+} from "../domains/dispatch/gate-decisions.js";
+import {
+	COMPETE_STANCES,
+	type CompeteStance,
+	JUDGE_GATE_PROMPT,
+	REVIEWER_GATE_PROMPT,
+} from "../domains/dispatch/gate-role-prompts.js";
+import { UNVERIFIABLE_RECEIPT_VERIFICATION } from "../domains/dispatch/receipt-findings.js";
+import { type ReceiptIntegrityResult, verifyReceiptIntegrity } from "../domains/dispatch/receipt-integrity.js";
+import { approvedRouteCandidates } from "../domains/dispatch/route-approval.js";
+import { defaultRoutingIntent, explainRouteDecision } from "../domains/dispatch/routing-intent.js";
+import type { RunGateProvenance, RunGateSubjectRef, RunPlanProvenance, RunReceipt } from "../domains/dispatch/types.js";
+import { DISPATCH_BRIEFING_MAX_BYTES, type DispatchFailoverMode } from "../domains/dispatch/validation.js";
+import { extractRunProvenance, provenanceCompactSuffix } from "../domains/evidence/provenance.js";
+import type { AutonomyLevel } from "../domains/safety/autonomy.js";
+import {
+	type CandidateWorktree,
+	type CompeteGroupOwnership,
+	candidateDiffStat,
+	claimCompeteGroup,
+	cleanupCompeteGroup,
+	commitCandidateWork,
+	createCandidateWorktree,
+	isGitRepository,
+	loadCompeteGroup,
+	markCompeteGroupCleanupReady,
+	markCompeteGroupWinnerPreserved,
+	mergeWinnerBranch,
+	protectedPathsChangedByCompeteBranch,
+	recoverCleanupReadyCompeteGroups,
+	registerCompeteGroupRun,
+	removeCandidateWorktree,
+	settleCompeteGroupRun,
+	settleRecoveredCompeteDecision,
+} from "./compete-worktrees.js";
+import {
+	dispatchRequestsFromArgs,
+	maxOutputBytesArg,
+	prepareDispatchArguments,
+	stringArg,
+	timeoutMsArg,
+} from "./dispatch-arguments.js";
+import {
+	DISPATCH_PLAN_PREPARATION_ERROR_ARGUMENT,
+	describeDispatchPlan,
+	RESOLVED_DISPATCH_PLAN_ARGUMENT,
+	type ResolvedDispatchPlanArtifact,
+	resolvedDispatchPlanFromArgs,
+	withResolvedDispatchPlan,
+	withResolvedPlanTaskPin,
+} from "./dispatch-plan.js";
+import {
+	loadVerifiedScoutSource,
+	prepareScoutContinuation,
+	runScoutContinuationPlan,
+	scoutContinuationRefFromArgs,
+	scoutPlanAuthorityGranted,
+	scoutTransitionDetail,
+} from "./dispatch-scout.js";
+import { TOOL_PROFILE_NAMES } from "./profiles.js";
+import type { ToolResult, ToolResultDetails, ToolSpec } from "./registry.js";
+import { stringEnum } from "./string-enum.js";
+import { truncateUtf8 } from "./truncate-utf8.js";
+import {
+	receiptEvidenceLabels,
+	SPOT_CHECK_GUIDANCE,
+	workerTextLabel,
+	workerTextNonEvidenceNotices,
+} from "./worker-evidence.js";
+
+const TRUNCATION_MARKER = "\n[agent output truncated]";
+const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+
+/**
+ * Result of an operator-initiated attach to detach conversion. The message is
+ * the line the keypress feedback renders, so a refusal names the topology that
+ * refused rather than reading as a dropped key.
+ */
+export type DispatchBackgroundOutcome = { ok: true; message: string } | { ok: false; message: string };
+
+export interface DispatchBackgroundControl {
+	/** Tool call the control belongs to; one attached dispatch owns one control. */
+	toolCallId: string;
+	/** Operator-facing name of the call, used in both outcome messages. */
+	label: string;
+	convert(): DispatchBackgroundOutcome;
+}
+
+/**
+ * Live attached dispatches that the operator may send to the background. An
+ * attached `dispatch` call registers one control for as long as it awaits its
+ * runs; the TUI keybinding fires the newest one. Absent from a deps bundle
+ * (workers, headless) nothing registers and attached dispatch behaves exactly
+ * as it did before.
+ */
+export interface DispatchBackgroundRegistry {
+	/** Returns the deregistration handle; calling it more than once is harmless. */
+	register(control: DispatchBackgroundControl): () => void;
+	/** Fire the newest still-registered control. */
+	backgroundNewest(): DispatchBackgroundOutcome;
+	/** How many attached dispatches are currently registered. */
+	size(): number;
+}
+
+export function createDispatchBackgroundRegistry(): DispatchBackgroundRegistry {
+	// Map insertion order is registration order, and the newest attached dispatch
+	// is the one the operator just watched start, so the keypress takes the last
+	// entry rather than asking a UI projection which segment is newest.
+	const controls = new Map<string, DispatchBackgroundControl>();
+	return {
+		register(control) {
+			controls.set(control.toolCallId, control);
+			return () => {
+				if (controls.get(control.toolCallId) === control) controls.delete(control.toolCallId);
+			};
+		},
+		backgroundNewest() {
+			let newest: DispatchBackgroundControl | undefined;
+			for (const control of controls.values()) newest = control;
+			if (newest === undefined) {
+				return { ok: false, message: "background: no attached dispatch is running" };
+			}
+			return newest.convert();
+		},
+		size: () => controls.size,
+	};
+}
+
+/**
+ * One-shot latch an attached executor races against its runs. Firing it never
+ * aborts anything: the registry drain that meters the runs was never owned by
+ * the awaiting code path, so unwinding the await leaves token metering, run
+ * tails, and bus progress flowing.
+ */
+interface BackgroundSwitch {
+	/** Resolves when the operator fires the control; never rejects. */
+	readonly requested: Promise<void>;
+	fire(): void;
+}
+
+function createBackgroundSwitch(): BackgroundSwitch {
+	let fired = false;
+	let signal = (): void => {};
+	const requested = new Promise<void>((resolve) => {
+		signal = resolve;
+	});
+	return {
+		requested,
+		fire: () => {
+			if (fired) return;
+			fired = true;
+			signal();
+		},
+	};
+}
+
+export interface DispatchToolDeps {
+	dispatch: DispatchContract;
+	bus?: SafeEventBus;
+	/** Instance-scoped owner for ordinary tool-owned run streams and monitor tails. */
+	runEvents?: DispatchRunEventRegistry;
+	/**
+	 * Operator-initiated backgrounding of an attached call. Wired only by the
+	 * interactive composition root, because only that process has a keypress to
+	 * fire the control with.
+	 */
+	background?: DispatchBackgroundRegistry;
+	/** Optional compete storage overrides for alternate backends and deterministic fault tests. */
+	competeWorktrees?: {
+		createCandidate?: typeof createCandidateWorktree;
+		cleanupGroup?: typeof cleanupCompeteGroup;
+		mergeWinner?: typeof mergeWinnerBranch;
+	};
+	getAgentCatalog?: () => string;
+	getAgentSpecs: () => ReadonlyArray<AgentSpec>;
+	getAgentRoleFacts?: AgentRoleFactsResolver;
+	/**
+	 * Session-effective autonomy level. Plan provenance records how the plan
+	 * gate resolved (operator approval versus full-auto logging) and compete
+	 * decides whether to apply the judge's pick or hand the winner to the
+	 * operator. Absent (minimal test bundles) defaults to auto-edit.
+	 */
+	getAutonomy?: () => AutonomyLevel;
+	/** Scheduling cost ceiling recorded on plan provenance when available. */
+	getCostCeilingUsd?: () => number;
+}
+
+interface EventSummary {
+	count: number;
+	types: string[];
+	lastAssistantText: string;
+	/** Immutable run id of the latest attempt represented by this assignment stream. */
+	terminalAttemptRunId: string;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+type ResolvedPlanTask = ResolvedDispatchPlanArtifact["tasks"][number];
+
+// In-process rolling tail of recent worker events, per run. Fed by the
+// dispatch tool's event consumption (the same stream the dispatch board
+// renders from the bus); read by monitor(mode="peek"). Bounded both per run
+// and across runs so long fleets cannot grow memory.
+const RUN_TAIL_ENTRY_LIMIT = 100;
+const RUN_TAIL_RUN_LIMIT = 64;
+const RUN_TAIL_TEXT_LIMIT = 600;
+
+export interface RunTailEntry {
+	at: string;
+	type: string;
+	detail?: string;
+}
+
+interface RunTailState {
+	agentId: string;
+	entries: RunTailEntry[];
+	lastSeenAt: number;
+}
+
+function eventDetail(event: unknown): string | undefined {
+	const text = assistantTextFromEvent(event);
+	if (text.length > 0) return truncateUtf8(text, RUN_TAIL_TEXT_LIMIT, "...");
+	if (!isRecord(event)) return undefined;
+	if (event.type === "clio_tool_finish" && isRecord(event.payload)) {
+		const tool = typeof event.payload.tool === "string" ? event.payload.tool : "tool";
+		const outcome = typeof event.payload.outcome === "string" ? event.payload.outcome : "";
+		return `${tool} ${outcome}`.trim();
+	}
+	if (event.type === "attempt_start") {
+		const attempt = typeof event.attempt === "number" ? event.attempt : "?";
+		const runId = typeof event.runId === "string" ? event.runId : "?";
+		const reason = typeof event.reason === "string" ? event.reason : "retry";
+		return truncateUtf8(`attempt ${attempt} -> ${runId}: ${reason}`, RUN_TAIL_TEXT_LIMIT, "...");
+	}
+	return undefined;
+}
+
+interface RegisteredSingleDispatch {
+	runId: string;
+	completion: Promise<{ receipt: RunReceipt; summary: EventSummary }>;
+}
+
+interface RegisteredBatchDispatch {
+	batchId: string;
+	assignmentIds: ReadonlyArray<string>;
+	completion: Promise<{ receipts: ReadonlyArray<RunReceipt>; summaries: Map<string, EventSummary> }>;
+}
+
+/**
+ * Instance-scoped owner of ordinary model-facing dispatch iterators and their
+ * monitor tails. Registering a handle starts its sole drain immediately; sync
+ * callers await `completion` while detached callers retain that same drain.
+ *
+ * Review and compete coordinators are intentional exceptions: they drain each
+ * gate-sensitive iterator directly, stage reviewer/judge output, and only then
+ * await the receipt. They use `recordEvent` to retain monitor-tail projection
+ * without surrendering iterator ownership to this registry.
+ */
+export interface DispatchRunEventRegistry {
+	registerSingle(
+		handle: Awaited<ReturnType<DispatchContract["dispatch"]>>,
+		agentId: string,
+		bus?: SafeEventBus,
+	): RegisteredSingleDispatch;
+	registerBatch(
+		handle: Awaited<ReturnType<DispatchContract["dispatchBatch"]>>,
+		agentIds: ReadonlyArray<string>,
+		bus?: SafeEventBus,
+	): RegisteredBatchDispatch;
+	recordEvent(runId: string, agentId: string, event: unknown): void;
+	eventTail(runId: string): { agentId: string; entries: ReadonlyArray<RunTailEntry> } | null;
+}
+
+export function createDispatchRunEventRegistry(): DispatchRunEventRegistry {
+	const runTails = new Map<string, RunTailState>();
+	const activeRuns = new Set<string>();
+	const activeBatches = new Set<string>();
+
+	const pruneRunTails = (): void => {
+		while (runTails.size > RUN_TAIL_RUN_LIMIT) {
+			let oldestKey: string | null = null;
+			let oldestSeen = Number.POSITIVE_INFINITY;
+			for (const [key, state] of runTails) {
+				if (activeRuns.has(key) || state.lastSeenAt >= oldestSeen) continue;
+				oldestKey = key;
+				oldestSeen = state.lastSeenAt;
+			}
+			if (oldestKey === null) break;
+			runTails.delete(oldestKey);
+		}
+	};
+
+	const recordRunEvent = (runId: string, agentId: string, event: unknown): void => {
+		const type = isRecord(event) && typeof event.type === "string" ? event.type : "unknown";
+		if (type === "heartbeat" || type === "message_update") return;
+		const state = runTails.get(runId) ?? { agentId, entries: [], lastSeenAt: Date.now() };
+		state.lastSeenAt = Date.now();
+		const entry: RunTailEntry = { at: new Date().toISOString(), type };
+		const detail = eventDetail(event);
+		if (detail !== undefined) entry.detail = detail;
+		state.entries.push(entry);
+		if (state.entries.length > RUN_TAIL_ENTRY_LIMIT) {
+			state.entries.splice(0, state.entries.length - RUN_TAIL_ENTRY_LIMIT);
+		}
+		runTails.set(runId, state);
+		pruneRunTails();
+	};
+
+	const drainSingle = async (
+		runId: string,
+		agentId: string,
+		events: AsyncIterableIterator<unknown>,
+		bus: SafeEventBus | undefined,
+	): Promise<EventSummary> => {
+		const summary: EventSummary = { count: 0, types: [], lastAssistantText: "", terminalAttemptRunId: runId };
+		for await (const event of events) {
+			summary.count += 1;
+			const type = isRecord(event) && typeof event.type === "string" ? event.type : "unknown";
+			summary.types.push(type);
+			// A superseded attempt's answer is not the assignment's answer: the
+			// failover marker discards it before the next attempt speaks.
+			if (type === "attempt_start") summary.lastAssistantText = "";
+			const text = rawAssistantTextFromEvent(event);
+			if (text.trim().length > 0) summary.lastAssistantText = text;
+			recordRunEvent(runId, agentId, event);
+			if (type !== "heartbeat") bus?.emit(BusChannels.DispatchProgress, { runId, agentId, event });
+		}
+		return summary;
+	};
+
+	const drainBatch = async (
+		batchId: string,
+		events: AsyncIterableIterator<unknown>,
+		bus: SafeEventBus | undefined,
+	): Promise<Map<string, EventSummary>> => {
+		const summaries = new Map<string, EventSummary>();
+		for await (const event of events) {
+			if (!isRecord(event) || event.type !== "batch_run_event") continue;
+			const runId = typeof event.runId === "string" ? event.runId : batchId;
+			const agentId = typeof event.agentId === "string" ? event.agentId : "batch";
+			const inner = event.event;
+			const summary = summaries.get(runId) ?? {
+				count: 0,
+				types: [],
+				lastAssistantText: "",
+				terminalAttemptRunId: runId,
+			};
+			summary.count += 1;
+			const type = isRecord(inner) && typeof inner.type === "string" ? inner.type : "unknown";
+			summary.types.push(type);
+			const text = rawAssistantTextFromEvent(inner);
+			if (text.trim().length > 0) summary.lastAssistantText = text;
+			summaries.set(runId, summary);
+			recordRunEvent(runId, agentId, inner);
+			if (type !== "heartbeat") bus?.emit(BusChannels.DispatchProgress, { runId, agentId, event: inner });
+		}
+		return summaries;
+	};
+
+	return {
+		registerSingle(handle, agentId, bus) {
+			if (activeRuns.has(handle.runId)) {
+				throw new Error(`dispatch event registry: run '${handle.runId}' is already registered`);
+			}
+			activeRuns.add(handle.runId);
+			const summaryPromise = drainSingle(handle.runId, agentId, handle.events, bus);
+			const completion = Promise.allSettled([summaryPromise, handle.finalPromise]).then(
+				([summaryResult, receiptResult]) => {
+					if (summaryResult.status === "rejected") throw summaryResult.reason;
+					if (receiptResult.status === "rejected") throw receiptResult.reason;
+					return { receipt: receiptResult.value, summary: summaryResult.value };
+				},
+			);
+			void completion
+				.finally(() => {
+					activeRuns.delete(handle.runId);
+					pruneRunTails();
+				})
+				.catch(() => {});
+			return { runId: handle.runId, completion };
+		},
+		registerBatch(handle, agentIds, bus) {
+			if (activeBatches.has(handle.batchId)) {
+				throw new Error(`dispatch event registry: batch '${handle.batchId}' is already registered`);
+			}
+			const duplicateRunId = handle.assignmentIds.find((runId, index) =>
+				handle.assignmentIds.slice(0, index).includes(runId),
+			);
+			if (duplicateRunId !== undefined) {
+				throw new Error(`dispatch event registry: batch '${handle.batchId}' repeats run '${duplicateRunId}'`);
+			}
+			const activeRunId = handle.assignmentIds.find((runId) => activeRuns.has(runId));
+			if (activeRunId !== undefined) {
+				throw new Error(`dispatch event registry: run '${activeRunId}' is already registered`);
+			}
+			activeBatches.add(handle.batchId);
+			for (const runId of handle.assignmentIds) activeRuns.add(runId);
+			const completion = Promise.allSettled([drainBatch(handle.batchId, handle.events, bus), handle.finalPromise]).then(
+				([summariesResult, receiptsResult]) => {
+					if (summariesResult.status === "rejected") throw summariesResult.reason;
+					if (receiptsResult.status === "rejected") throw receiptsResult.reason;
+					return { receipts: receiptsResult.value, summaries: summariesResult.value };
+				},
+			);
+			void completion
+				.finally(() => {
+					activeBatches.delete(handle.batchId);
+					for (const runId of handle.assignmentIds) activeRuns.delete(runId);
+					pruneRunTails();
+				})
+				.catch(() => {});
+			// Seed agent routing even when a run completes before its first event.
+			for (const [index, runId] of handle.assignmentIds.entries()) {
+				if (!runTails.has(runId)) {
+					runTails.set(runId, { agentId: agentIds[index] ?? "unknown", entries: [], lastSeenAt: Date.now() });
+				}
+			}
+			return { batchId: handle.batchId, assignmentIds: handle.assignmentIds, completion };
+		},
+		recordEvent: recordRunEvent,
+		eventTail(runId) {
+			const state = runTails.get(runId);
+			if (!state) return null;
+			return { agentId: state.agentId, entries: [...state.entries] };
+		},
+	};
+}
+
+function rawAssistantTextFromEvent(event: unknown): string {
+	return durableAssistantTextFromEvent(event);
+}
+
+export function assistantTextFromEvent(event: unknown): string {
+	return rawAssistantTextFromEvent(event).trim();
+}
+
+function normalizedAssistantText(summary: EventSummary): string {
+	return summary.lastAssistantText.trim();
+}
+
+type RegisteredDispatchToolDeps = DispatchToolDeps & { runEvents: DispatchRunEventRegistry };
+
+function fallbackProgressBus(deps: DispatchToolDeps): SafeEventBus | undefined {
+	return deps.dispatch.ownsProgressBus?.(deps.bus) === true ? undefined : deps.bus;
+}
+
+/**
+ * Gate-sensitive coordinator drain. Review and compete must finish this drain
+ * and stage pending decision output before awaiting the receipt-facing final
+ * promise; the ordinary registry's concurrent join cannot provide that edge.
+ */
+async function consumeGateSensitiveDispatchEvents(
+	deps: RegisteredDispatchToolDeps,
+	runId: string,
+	agentId: string,
+	events: AsyncIterableIterator<unknown>,
+): Promise<EventSummary> {
+	const summary: EventSummary = { count: 0, types: [], lastAssistantText: "", terminalAttemptRunId: runId };
+	const bus = fallbackProgressBus(deps);
+	for await (const event of events) {
+		summary.count += 1;
+		const type = isRecord(event) && typeof event.type === "string" ? event.type : "unknown";
+		summary.types.push(type);
+		if (type === "attempt_start" && isRecord(event) && typeof event.runId === "string" && event.runId.length > 0) {
+			summary.terminalAttemptRunId = event.runId;
+		}
+		const text = rawAssistantTextFromEvent(event);
+		if (text.trim().length > 0) summary.lastAssistantText = text;
+		deps.runEvents.recordEvent(runId, agentId, event);
+		if (type !== "heartbeat") bus?.emit(BusChannels.DispatchProgress, { runId, agentId, event });
+	}
+	return summary;
+}
+
+/**
+ * Fan out without waiting: admit and spawn every task, persist the durable
+ * batch record, then hand the merged event stream to a background drain so
+ * token metering, run tails (monitor peek), and bus progress keep flowing
+ * while the orchestrator's turn continues. The tool result carries only the
+ * batch id and run ids; results are gathered later through monitor
+ * mode="wait"/"collect", in this session or after a resume.
+ */
+async function runDetached(
+	deps: RegisteredDispatchToolDeps,
+	requests: ReadonlyArray<DispatchRequest>,
+	sessionId: string | null,
+): Promise<ToolResult> {
+	const detached = deps.dispatch.detached;
+	if (!detached) {
+		return { kind: "error", message: "dispatch: detach is not supported in this context" };
+	}
+	// Detached runs are concurrent peers too, so they get a board whenever there
+	// is more than one of them. Collection closes it, which can happen in a later
+	// process, so the batch record carries the id.
+	const ledgerId = requests.length >= 2 ? newGateGroupId("ledger") : null;
+	if (ledgerId !== null) await openAgentLedger(ledgerId);
+	const ledgered =
+		ledgerId === null ? requests : requests.map((request) => ({ ...request, ledger: { id: ledgerId, sequence: 0 } }));
+	const handle = await deps.dispatch.dispatchBatch(ledgered);
+	const registered = deps.runEvents.registerBatch(
+		handle,
+		ledgered.map((request) => request.agentId),
+		fallbackProgressBus(deps),
+	);
+	const assignmentIds = handle.assignmentIds;
+	const runs = handle.assignmentIds.map((runId, index) => ({
+		runId,
+		assignmentId: assignmentIds[index] ?? runId,
+		agentId: requests[index]?.agentId ?? "unknown",
+	}));
+	registered.completion.catch(() => {});
+	// The runs are live; make their assignment records durable before returning
+	// so an immediate collect resolves the logical assignment (and any queued
+	// retry) instead of falling back to a bare, possibly-failed first attempt.
+	await deps.dispatch.assignments?.flushWrites?.();
+	try {
+		await detached.register({
+			batchId: handle.batchId,
+			runs,
+			sessionId,
+			...(ledgerId !== null ? { ledgerId } : {}),
+		});
+	} catch (err) {
+		// The runs are already live; report the durability gap instead of
+		// pretending the batch does not exist.
+		const message = err instanceof Error ? err.message : String(err);
+		return {
+			kind: "error",
+			message: `dispatch: detached assignments started (batch=${handle.batchId}, assignments=${handle.assignmentIds.join(", ")}) but the durable batch record failed: ${message}`,
+			details: { mode: "detached", batchId: handle.batchId, assignmentIds: [...handle.assignmentIds] },
+		};
+	}
+	const lines = [
+		`dispatch (detached) batch=${handle.batchId} started ${runs.length} run(s)`,
+		...runs.map((run) => `- ${run.assignmentId} agent=${run.agentId}`),
+		"",
+		`Runs continue in the background. Collect results with monitor(mode="collect", batch_id="${handle.batchId}"); block on one run with monitor(mode="wait", run_id=<id>).`,
+	];
+	return {
+		kind: "ok",
+		output: lines.join("\n"),
+		details: {
+			mode: "detached",
+			batchId: handle.batchId,
+			assignmentIds: [...handle.assignmentIds],
+			runs: runs.map((run) => ({ runId: run.runId, assignmentId: run.assignmentId, agentId: run.agentId })),
+		},
+	};
+}
+
+/**
+ * Publish this call's conversion control for as long as its topology branch
+ * runs. A refusing control still registers: the operator who pressed the key
+ * needs the topology's reason, and an unregistered call would answer with the
+ * "nothing running" no-op instead.
+ */
+function registerBackgroundControl(
+	deps: DispatchToolDeps,
+	toolCallId: string | undefined,
+	plan: { label: string; refusal: string | null; fire: () => void },
+): () => void {
+	const registry = deps.background;
+	if (registry === undefined || toolCallId === undefined || toolCallId.length === 0) return () => {};
+	let release = (): void => {};
+	release = registry.register({
+		toolCallId,
+		label: plan.label,
+		convert: () => {
+			if (plan.refusal !== null) {
+				return { ok: false, message: `${plan.label} cannot be backgrounded: ${plan.refusal}` };
+			}
+			// Drop the control before firing so a second keypress reaches the next
+			// attached dispatch instead of re-firing a converted one.
+			release();
+			plan.fire();
+			return { ok: true, message: `${plan.label} is moving to the background as a detached batch` };
+		},
+	});
+	return () => release();
+}
+
+/**
+ * Thrown out of an attached executor when the operator converts the call to a
+ * detached batch. The runs keep going; only the await unwinds. `settled` names
+ * sequential steps that already finished, and `undispatched` names later steps
+ * that were never started, because a mid-sequence conversion really does leave
+ * them unstarted and reporting a completed sequence would be a lie.
+ */
+class DispatchBackgroundedError extends Error {
+	constructor(
+		readonly batchId: string,
+		readonly live: ReadonlyArray<DetachedBatchRun>,
+		readonly settled: ReadonlyArray<CompletedRun>,
+		readonly undispatched: ReadonlyArray<string>,
+		/**
+		 * The agent ledger the live runs still share. It stays open across the
+		 * conversion and rides on the detached record so collect closes it, the
+		 * same as a batch that was detached from the start.
+		 */
+		readonly ledgerId: string | null = null,
+	) {
+		super("dispatch: backgrounded by operator");
+		this.name = "DispatchBackgroundedError";
+	}
+}
+
+/**
+ * Finish an operator-initiated conversion: persist the same durable batch
+ * record a `detach: true` call would have written, so monitor collect, the
+ * completion nudge, and resume all attach to it exactly as they do for a
+ * model-initiated detach, then answer the model in the detached shape.
+ */
+async function backgroundedDispatchResult(
+	deps: RegisteredDispatchToolDeps,
+	converted: DispatchBackgroundedError,
+	mode: string,
+	sessionId: string | null,
+): Promise<ToolResult> {
+	const liveIds = converted.live.map((run) => run.assignmentId);
+	const detached = deps.dispatch.detached;
+	if (!detached) {
+		return {
+			kind: "error",
+			message: `dispatch: the operator moved this call to the background, but detached batch records are unavailable in this context; ${liveIds.join(", ")} keep running and can only be reached with monitor(mode="wait", run_id=<id>)`,
+			details: { mode: "detached", assignmentIds: liveIds },
+		};
+	}
+	// Same ordering as runDetached: the runs are already live, so their
+	// assignment records must land before the batch record an immediate collect
+	// would resolve through.
+	await deps.dispatch.assignments?.flushWrites?.();
+	try {
+		await detached.register({
+			batchId: converted.batchId,
+			runs: converted.live,
+			sessionId,
+			...(converted.ledgerId !== null ? { ledgerId: converted.ledgerId } : {}),
+		});
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		return {
+			kind: "error",
+			message: `dispatch: the operator moved this call to the background (batch=${converted.batchId}, assignments=${liveIds.join(", ")}) but the durable batch record failed: ${message}`,
+			details: { mode: "detached", batchId: converted.batchId, assignmentIds: liveIds },
+		};
+	}
+	const lines = [
+		`dispatch (${mode}) was moved to the background by the operator: batch=${converted.batchId} holds ${converted.live.length} still-running assignment(s)`,
+		...converted.live.map((run) => `- ${run.assignmentId} agent=${run.agentId}`),
+	];
+	if (converted.settled.length > 0) {
+		lines.push(
+			`${converted.settled.length} earlier ${mode} step(s) had already finished and are not in this batch: ${converted.settled.map((run) => run.receipt.runId).join(", ")}. Read them with monitor(mode="receipt", run_id=<id>).`,
+		);
+	}
+	if (converted.undispatched.length > 0) {
+		lines.push(
+			`${converted.undispatched.length} later ${mode} step(s) were never dispatched (agents: ${converted.undispatched.join(", ")}); re-issue them if they are still wanted.`,
+		);
+	}
+	lines.push(
+		"",
+		`Runs continue in the background. Collect results with monitor(mode="collect", batch_id="${converted.batchId}"); block on one run with monitor(mode="wait", run_id=<id>).`,
+	);
+	return {
+		kind: "ok",
+		output: lines.join("\n"),
+		details: {
+			mode: "detached",
+			conversion: "operator-backgrounded",
+			batchId: converted.batchId,
+			assignmentIds: liveIds,
+			runs: converted.live.map((run) => ({ runId: run.runId, assignmentId: run.assignmentId, agentId: run.agentId })),
+			settledRunIds: converted.settled.map((run) => run.receipt.runId),
+			undispatchedAgentIds: [...converted.undispatched],
+		},
+	};
+}
+
+/**
+ * Surfaces a succeeded run's outcomeDetail to the calling model. Today that
+ * detail is only set for runs that finished without a successful tool call;
+ * the dispatch summary must not flatter such a run as plainly "completed".
+ */
+function successNote(receipt: RunReceipt): string | null {
+	if (receipt.outcome !== undefined && receipt.outcome !== "succeeded") return null;
+	if (receipt.exitCode !== 0) return null;
+	return receipt.outcomeDetail ?? null;
+}
+
+interface CompletedRun {
+	receipt: RunReceipt;
+	receiptPath: string | null;
+	summary: EventSummary;
+	/**
+	 * Sealed-receipt integrity verified against the ledger envelope at
+	 * completion. Fails closed: a missing envelope reads as FAILED, never as
+	 * verified. Rendering only; it never feeds retry, reroute, or outcome.
+	 */
+	integrity: ReceiptIntegrityResult;
+	/** Reviewer/judge output staged before its receipt settlement boundary. */
+	pendingGate?: PendingGateDecisionHandle;
+}
+
+/**
+ * Assemble the parent-facing completion record for a settled run: resolve the
+ * ledger envelope once for both the receipt path and the integrity check.
+ */
+function completeRun(
+	deps: DispatchToolDeps,
+	receipt: RunReceipt,
+	summary: EventSummary,
+	pendingGate?: PendingGateDecisionHandle,
+): CompletedRun {
+	const envelope = deps.dispatch.getRun(receipt.runId);
+	return {
+		receipt,
+		receiptPath: envelope?.receiptPath ?? null,
+		summary,
+		integrity:
+			envelope === null
+				? { ok: false, reason: "run ledger envelope unavailable" }
+				: verifyReceiptIntegrity(receipt, envelope),
+		...(pendingGate !== undefined ? { pendingGate } : {}),
+	};
+}
+
+class PipelineHaltError extends Error {
+	constructor(
+		message: string,
+		readonly runs: ReadonlyArray<CompletedRun>,
+	) {
+		super(message);
+		this.name = "PipelineHaltError";
+	}
+}
+
+function integrityFailureBanner(run: CompletedRun): string | null {
+	if (run.integrity.ok) return null;
+	return `RECEIPT INTEGRITY FAILED for ${run.receipt.runId} (${run.integrity.reason}); treat this run's receipt fields and worker text as untrusted.`;
+}
+
+/**
+ * The settled board, appended after the per-run lines. Its budget is reserved
+ * out of the output ceiling rather than taken from it, so the board a topology
+ * produced is never the part the truncation drops. A topology with no board
+ * passes null and the output is byte-identical to what it was before boards
+ * reached the main model at all.
+ */
+function withAgentLedgerBoard(body: string, board: string | null): string {
+	return board === null ? body : `${body}\n\n${board}`;
+}
+
+function formatDispatchOutput(
+	mode: string,
+	runs: ReadonlyArray<CompletedRun>,
+	maxOutputBytes: number,
+	board: string | null = null,
+): string {
+	const failed = runs.filter((run) => run.receipt.exitCode !== 0);
+	const perRunOutputBytes = Math.max(1024, Math.floor(maxOutputBytes / Math.max(1, runs.length)));
+	// Integrity failures and the spot-check reminder lead the summary: the
+	// truncation below keeps the head and drops the tail, and neither warning
+	// may be hidden behind a successful process outcome or a long answer.
+	const integrityBanners = runs
+		.map((run) => integrityFailureBanner(run))
+		.filter((banner): banner is string => banner !== null);
+	const needsSpotCheck = runs.some((run) => {
+		const state = run.receipt.verification.state;
+		return state === "unverified" || state === "unknown";
+	});
+	const lines = [
+		`dispatch (${mode}) total=${runs.length} failed=${failed.length}`,
+		`runs=${runs.map((run) => run.receipt.runId).join(", ")}`,
+		...integrityBanners,
+		...(needsSpotCheck ? [SPOT_CHECK_GUIDANCE] : []),
+		"",
+		...runs.flatMap((run, index) => {
+			const { receipt, receiptPath } = run;
+			const note = successNote(receipt);
+			const noteSuffix = note !== null ? ` note=${note}` : "";
+			// A non-success outcome is load-bearing evidence (a timeout has no
+			// failureMessage at all); render it and its detail on the run line.
+			const outcomeSuffix =
+				receipt.outcome !== undefined && receipt.outcome !== "succeeded"
+					? ` outcome=${receipt.outcome}${receipt.outcomeDetail ? ` detail=${receipt.outcomeDetail}` : ""}`
+					: "";
+			const failure = receipt.failureMessage ? ` failure=${receipt.failureMessage}` : "";
+			// Pipeline runs are an ordered chain, so each line names its step.
+			const stepLabel = mode === "pipeline" ? `step ${index + 1}/${runs.length} ` : "";
+			// Provenance suffix is empty when a run carries no
+			// pipeline/persona/escalation fields, so the line format is unchanged.
+			const provenance = provenanceCompactSuffix(extractRunProvenance(receipt));
+			// Evidence confidence comes from the sealed receipt. A receipt that fails
+			// integrity cannot be read as evidence at all.
+			const verification = run.integrity.ok ? receipt.verification : UNVERIFIABLE_RECEIPT_VERIFICATION;
+			const evidenceSuffix = ` ${receiptEvidenceLabels(receipt, verification, run.integrity).join(" ")}${
+				run.integrity.ok ? "" : " evidence_verification=unknown/receipt-integrity-failed"
+			}`;
+			const routingSuffix =
+				run.integrity.ok && receipt.routeDecision !== undefined && receipt.routingIntent !== undefined
+					? ` route_decision=${receipt.routeDecision.decisionHash} route_mode=${receipt.routeDecision.mode}`
+					: "";
+			// The sealed receipt is authoritative. Live summaries remain useful for
+			// monitoring but can contain transient tool-use prose and never override
+			// a missing, partial, or integrity-invalid durable answer.
+			const answerText =
+				run.integrity.ok &&
+				(receipt.output?.state === "final" || (receipt.outcome !== undefined && receipt.outcome !== "succeeded"))
+					? (receipt.output?.text ?? "")
+					: "";
+			const output =
+				answerText.length > 0
+					? truncateUtf8(answerText, perRunOutputBytes, TRUNCATION_MARKER)
+					: run.integrity.ok
+						? "(no receipt-sealed assistant text captured)"
+						: "(worker text withheld because receipt integrity failed)";
+			return [
+				`- ${stepLabel}${receipt.runId} agent=${receipt.agentId} exit=${receipt.exitCode} target=${receipt.targetId} model=${receipt.wireModelId} tokens=${receipt.tokenCount} receipt=${receiptPath ?? "n/a"}${evidenceSuffix}${outcomeSuffix}${noteSuffix}${failure}${provenance}${routingSuffix}`,
+				`  ${workerTextLabel(verification)}`,
+				...output.split("\n").map((line) => `  ${line}`),
+				...workerTextNonEvidenceNotices(receipt, verification, answerText).map((notice) => `  ${notice}`),
+			];
+		}),
+	];
+	if (board === null) return truncateUtf8(lines.join("\n"), maxOutputBytes, TRUNCATION_MARKER);
+	const runBudget = Math.max(1024, maxOutputBytes - Buffer.byteLength(board, "utf8") - 2);
+	return withAgentLedgerBoard(truncateUtf8(lines.join("\n"), runBudget, TRUNCATION_MARKER), board);
+}
+
+function dispatchDetails(
+	deps: DispatchToolDeps,
+	mode: string,
+	runs: ReadonlyArray<CompletedRun>,
+	board: string | null = null,
+): ToolResultDetails {
+	const failed = runs.filter((run) => run.receipt.exitCode !== 0);
+	let transition: ReturnType<typeof scoutTransitionDetail> = null;
+	for (const run of runs) {
+		const envelope = deps.dispatch.getRun(run.receipt.runId);
+		const candidate =
+			run.integrity.ok && envelope !== null
+				? scoutTransitionDetail({ receipt: run.receipt, envelope, agentSpecs: deps.getAgentSpecs() })
+				: null;
+		if (candidate === null) continue;
+		if (transition !== null) {
+			transition = null;
+			break;
+		}
+		transition = candidate;
+	}
+	return {
+		mode,
+		assignmentIds: runs.map((run) => run.receipt.lineage?.rootRunId ?? run.receipt.runId),
+		terminalRunIds: runs.map((run) => run.receipt.runId),
+		receiptCount: runs.length,
+		failedCount: failed.length,
+		// Same text the output carries, under a stable key, so a surface that
+		// renders details can show the board without re-reading the store.
+		...(board !== null ? { agentLedgerBoard: board } : {}),
+		...(transition !== null ? { scoutTransition: transition } : {}),
+		runs: runs.map(({ receipt, receiptPath, summary, integrity }) => {
+			// Additive provenance keys only; folded in when the receipt carries the
+			// field so a run entry without them keeps its exact shape.
+			const provenance = extractRunProvenance(receipt);
+			return {
+				runId: receipt.runId,
+				agentId: receipt.agentId,
+				exitCode: receipt.exitCode,
+				receiptPath,
+				eventCount: summary.count,
+				// Structured evidence state for downstream consumers: mirrors the
+				// sealed receipt read-only, plus the integrity check so a tampered
+				// receipt is machine-visible here too.
+				verification: integrity.ok ? receipt.verification : UNVERIFIABLE_RECEIPT_VERIFICATION,
+				receiptIntegrity: integrity,
+				...(receipt.outcome !== undefined && receipt.outcome !== "succeeded"
+					? { outcome: receipt.outcome, outcomeDetail: receipt.outcomeDetail ?? null }
+					: {}),
+				...(provenance.pipeline !== undefined ? { pipeline: provenance.pipeline } : {}),
+				...(provenance.personaOverride !== undefined ? { personaOverride: provenance.personaOverride } : {}),
+				...(provenance.escalation !== undefined ? { escalation: provenance.escalation } : {}),
+				...(provenance.autonomyEnforcement !== undefined ? { autonomyEnforcement: provenance.autonomyEnforcement } : {}),
+				...(integrity.ok && receipt.routeDecision !== undefined && receipt.routingIntent !== undefined
+					? { routing: explainRouteDecision(receipt.routeDecision, receipt.routingIntent) }
+					: {}),
+			};
+		}),
+	};
+}
+
+function newGateGroupId(prefix: string): string {
+	return `${prefix}-${Date.now().toString(36)}-${randomBytes(3).toString("hex")}`;
+}
+
+function subjectRef(receipt: RunReceipt): RunGateSubjectRef {
+	return { runId: receipt.runId, digest: receipt.integrity?.digest ?? null };
+}
+
+/**
+ * Sealed correlation between a decider route and the subject route it graded.
+ * Reported on every decision, including when no independent route exists.
+ */
+function gateCorrelationOf(subject: RunReceipt, decider: RunReceipt): GateDecisionCorrelation {
+	const facts = (receipt: RunReceipt): RouteCorrelationFacts => ({
+		agentId: receipt.agentId,
+		targetId: receipt.targetId,
+		wireModelId: receipt.wireModelId,
+		runtimeId: receipt.runtimeId,
+		nodeId: receipt.node?.id ?? "local",
+	});
+	const { agent, target, modelFamily, runtime, node, independent } = gateRouteCorrelation(
+		facts(subject),
+		facts(decider),
+	);
+	return { agent, target, modelFamily, runtime, node, independent };
+}
+
+/** Compete candidates share the base request's agent and model, so the first is representative. */
+function competeCorrelation(
+	candidates: ReadonlyArray<{ receipt: RunReceipt }>,
+	decider: RunReceipt,
+): GateDecisionCorrelation {
+	const subject = candidates[0]?.receipt;
+	if (subject === undefined) throw new Error("compete decision requires at least one candidate receipt");
+	return gateCorrelationOf(subject, decider);
+}
+
+function reviewerTask(originalTask: string, builderRunId: string, cycle: number): string {
+	return [
+		`Review the work of builder run ${builderRunId} (review cycle ${cycle}).`,
+		"The builder's final answer is provided as input data; verify it against the workspace, do not trust it blindly.",
+		"Original task the builder was given:",
+		originalTask,
+	].join("\n\n");
+}
+
+export interface ReviewGateSettings {
+	reviewer?: string;
+	maxCycles: number;
+	node?: string;
+	model?: string;
+	target?: string;
+	/** Immutable per-cycle builder/reviewer pins expanded by plan admission. */
+	resolvedTasks?: ReadonlyArray<ResolvedPlanTask>;
+}
+
+const REVIEW_MAX_CYCLES_DEFAULT = 2;
+const REVIEW_MAX_CYCLES_LIMIT = 4;
+
+const REVIEW_SINGLE_TASK_MESSAGE =
+	"dispatch: review supports exactly one task; run the fan-out without review, then dispatch one integration task with review to gate the combined result";
+const COMPETE_SINGLE_TASK_MESSAGE = "dispatch: compete requires exactly one task";
+const COMPETE_NO_REVIEW_MESSAGE = "dispatch: compete has its own judge and cannot combine with review";
+
+function reviewSettingsFromArgs(
+	args: Record<string, unknown>,
+): { ok: true; review: ReviewGateSettings | undefined } | { ok: false; message: string } {
+	const raw = args.review;
+	if (raw === undefined || raw === false) return { ok: true, review: undefined };
+	const record = raw === true ? {} : isRecord(raw) ? raw : null;
+	if (record === null) return { ok: false, message: "dispatch: review must be true or an options object" };
+	const review: ReviewGateSettings = { maxCycles: REVIEW_MAX_CYCLES_DEFAULT };
+	const reviewer = stringArg(record, "reviewer", "agent");
+	if (reviewer) review.reviewer = reviewer;
+	if (record.max_cycles !== undefined) {
+		const cycles = record.max_cycles;
+		if (typeof cycles !== "number" || !Number.isInteger(cycles) || cycles < 1 || cycles > REVIEW_MAX_CYCLES_LIMIT) {
+			return { ok: false, message: `dispatch: review.max_cycles must be an integer 1..${REVIEW_MAX_CYCLES_LIMIT}` };
+		}
+		review.maxCycles = cycles;
+	}
+	const node = stringArg(record, "node");
+	if (node) review.node = node;
+	const model = stringArg(record, "model");
+	if (model) review.model = model;
+	const target = stringArg(record, "target");
+	if (target) review.target = target;
+	return { ok: true, review };
+}
+
+interface GateRunOutcome {
+	runs: CompletedRun[];
+	decisions: Array<{ artifact: GateDecisionArtifact; path: string }>;
+	verdict: "pass" | "fail" | null;
+	cycles: number;
+	/** Set when the gate ended without a pass/fail verdict and needs the operator. */
+	needsDecision?: string;
+}
+
+/**
+ * Reviewer-gated dispatch: the builder runs, a read-only reviewer evaluates
+ * the workspace against the task, and a revise verdict re-runs the builder
+ * with the findings threaded as input data. Bounded by maxCycles; exhaustion
+ * (or an unparseable reviewer answer at the last cycle) surfaces as a
+ * needs-decision outcome, never a silent failure. Receipts chain backward:
+ * each reviewer references the builder it reviewed, each revise builder
+ * references the reviewer whose findings it received.
+ */
+async function runReviewGated(
+	deps: RegisteredDispatchToolDeps,
+	base: DispatchRequest,
+	review: ReviewGateSettings,
+	timeoutMs: number | undefined,
+	signal: AbortSignal | undefined,
+): Promise<GateRunOutcome> {
+	const group = newGateGroupId("review");
+	const runs: CompletedRun[] = [];
+	const decisions: Array<{ artifact: GateDecisionArtifact; path: string }> = [];
+	const recordDecision = (
+		draft: GateDecisionDraft,
+		pending?: PendingGateDecisionHandle,
+	): { artifact: GateDecisionArtifact; path: string } => {
+		const decision = pending
+			? finalizePendingGateDecision(pending, draft)
+			: materializePendingGateDecision(stagePendingGateDecision(draft));
+		decisions.push(decision);
+		return decision;
+	};
+	let expired = false;
+	let activeRunId: string | null = null;
+	const abortActive = (bySignal: boolean): void => {
+		expired = true;
+		if (activeRunId !== null) {
+			deps.dispatch.abort(
+				activeRunId,
+				bySignal ? undefined : { cause: "timeout", detail: `timed out after ${timeoutMs}ms` },
+			);
+		}
+	};
+	const onSignalAbort = (): void => abortActive(true);
+	const timer = timeoutMs !== undefined ? setTimeout(() => abortActive(false), timeoutMs) : null;
+	signal?.addEventListener("abort", onSignalAbort, { once: true });
+
+	const runOne = async (request: DispatchRequest): Promise<CompletedRun> => {
+		if (expired || signal?.aborted) {
+			throw new Error(
+				`review dispatch stopped after ${runs.length} run(s): ${signal?.aborted ? "aborted" : `timed out after ${timeoutMs}ms`}`,
+			);
+		}
+		const handle = await deps.dispatch.dispatch(request);
+		activeRunId = handle.runId;
+		const summary = await consumeGateSensitiveDispatchEvents(deps, handle.runId, request.agentId, handle.events);
+		let pendingGate: PendingGateDecisionHandle | undefined;
+		if (request.gate?.role === "reviewer") {
+			try {
+				pendingGate = stagePendingGateOutput({
+					group: request.gate.group,
+					topology: "review",
+					cycle: request.gate.cycle,
+					subjects: request.gate.subjects ?? [],
+					deciderRunId: summary.terminalAttemptRunId,
+					finalOutput: normalizedAssistantText(summary),
+					terminalCycle: request.gate.cycle === review.maxCycles,
+				});
+			} catch (error) {
+				try {
+					deps.dispatch.abort(handle.runId);
+				} catch {
+					// The receipt barrier below still observes the admitted process.
+				}
+				await Promise.allSettled([handle.finalPromise]);
+				activeRunId = null;
+				throw error;
+			}
+		}
+		let receipt: RunReceipt;
+		try {
+			receipt = await handle.finalPromise;
+		} finally {
+			activeRunId = null;
+		}
+		const completed = completeRun(deps, receipt, summary, pendingGate);
+		runs.push(completed);
+		return completed;
+	};
+
+	try {
+		let findings: { reviewer: CompletedRun; text: string } | null = null;
+		for (let cycle = 1; cycle <= review.maxCycles; cycle += 1) {
+			const builderGate: RunGateProvenance = {
+				role: "builder",
+				group,
+				cycle,
+				...(findings !== null ? { subjects: [subjectRef(findings.reviewer.receipt)], verdict: "revise" } : {}),
+			};
+			const builderRequest: DispatchRequest = {
+				...base,
+				executionRole: "builder",
+				gate: builderGate,
+				...(findings !== null
+					? { pipelineInput: { fromRunId: findings.reviewer.receipt.runId, position: cycle, text: findings.text } }
+					: {}),
+			};
+			const builder = await runOne(
+				withResolvedPlanTaskPin(
+					builderRequest,
+					review.resolvedTasks?.find((task) => task.role === "builder" && task.position === cycle),
+				),
+			);
+			if (isPipelineStepFailure(builder.receipt)) {
+				recordDecision({
+					group,
+					topology: "review",
+					cycle,
+					outcome: "exhausted",
+					subjects: [subjectRef(builder.receipt)],
+					detail: `builder ended ${pipelineFailureReason(builder.receipt)}`,
+				});
+				return {
+					runs,
+					decisions,
+					verdict: null,
+					cycles: cycle,
+					needsDecision: `builder run ${builder.receipt.runId} ended ${pipelineFailureReason(builder.receipt)} in cycle ${cycle}`,
+				};
+			}
+			const reviewerRequest: DispatchRequest = {
+				agentId: gateDeciderAgentId(review.reviewer),
+				executionRole: "reviewer",
+				task: reviewerTask(base.task, builder.receipt.runId, cycle),
+				systemPrompt: REVIEWER_GATE_PROMPT,
+				autonomy: "read-only",
+				gate: { role: "reviewer", group, cycle, subjects: [subjectRef(builder.receipt)] },
+				pipelineInput: {
+					fromRunId: builder.receipt.runId,
+					position: cycle,
+					text: normalizedAssistantText(builder.summary),
+				},
+				...(base.cwd !== undefined ? { cwd: base.cwd } : {}),
+				...(review.node !== undefined ? { node: review.node } : {}),
+				...(review.model !== undefined ? { model: review.model } : {}),
+				...(review.target !== undefined ? { target: review.target } : {}),
+				...(base.plan !== undefined ? { plan: base.plan } : {}),
+				...(base.parentToolCallId !== undefined ? { parentToolCallId: base.parentToolCallId } : {}),
+				...(base.reservation !== undefined
+					? { reservation: { ownerId: base.reservation.ownerId, memberId: base.reservation.memberId } }
+					: {}),
+			};
+			const reviewer = await runOne(
+				withResolvedPlanTaskPin(
+					reviewerRequest,
+					review.resolvedTasks?.find((task) => task.role === "reviewer" && task.position === cycle),
+					{ pinTask: false },
+				),
+			);
+			if (isPipelineStepFailure(reviewer.receipt)) {
+				recordDecision(
+					{
+						group,
+						topology: "review",
+						cycle,
+						outcome: "exhausted",
+						subjects: [subjectRef(builder.receipt)],
+						decider: subjectRef(reviewer.receipt),
+						correlation: gateCorrelationOf(builder.receipt, reviewer.receipt),
+						detail: `reviewer ended ${pipelineFailureReason(reviewer.receipt)}`,
+					},
+					reviewer.pendingGate,
+				);
+				return {
+					runs,
+					decisions,
+					verdict: null,
+					cycles: cycle,
+					needsDecision: `reviewer run ${reviewer.receipt.runId} ended ${pipelineFailureReason(reviewer.receipt)} in cycle ${cycle}`,
+				};
+			}
+			const decided = decideReviewGate({
+				group,
+				cycle,
+				terminalCycle: cycle === review.maxCycles,
+				subjects: [subjectRef(builder.receipt)],
+				decider: subjectRef(reviewer.receipt),
+				correlation: gateCorrelationOf(builder.receipt, reviewer.receipt),
+				output: normalizedAssistantText(reviewer.summary),
+			});
+			recordDecision(decided.draft, reviewer.pendingGate);
+			if (decided.findings === null) {
+				return {
+					runs,
+					decisions,
+					verdict: decided.verdict,
+					cycles: cycle,
+					...(decided.needsDecision !== null ? { needsDecision: decided.needsDecision } : {}),
+				};
+			}
+			findings = { reviewer, text: decided.findings };
+		}
+		throw new Error("review gate exhausted without terminal decision evidence");
+	} finally {
+		if (timer) clearTimeout(timer);
+		signal?.removeEventListener("abort", onSignalAbort);
+	}
+}
+
+function judgeTask(originalTask: string, candidates: ReadonlyArray<CandidateWorktree>, stats: string[]): string {
+	const lines = [
+		`Rank ${candidates.length} candidate implementations of this task and pick the best one.`,
+		"Original task:",
+		originalTask,
+		"Candidates:",
+		...candidates.map(
+			(candidate, index) =>
+				`  ${candidate.index}. branch=${candidate.branch} worktree=${candidate.path} (${stats[index] ?? "?"})`,
+		),
+	];
+	return lines.join("\n\n");
+}
+
+function readVerifiedGateReceipt(deps: DispatchToolDeps, runId: string): RunReceipt | null {
+	const envelope = deps.dispatch.getRun(runId);
+	if (envelope === null) return null;
+	const path = envelope.receiptPath ?? join(clioStateDir(), "receipts", `${runId}.json`);
+	if (!existsSync(path)) return null;
+	let receipt: RunReceipt;
+	try {
+		receipt = JSON.parse(readFileSync(path, "utf8")) as RunReceipt;
+	} catch (error) {
+		throw new Error(`pending gate receipt ${runId} is unreadable: ${competeErrorMessage(error)}`);
+	}
+	if (receipt.runId !== runId) throw new Error(`pending gate receipt path for ${runId} contains ${receipt.runId}`);
+	const verification = verifyReceiptIntegrity(receipt, envelope);
+	if (!verification.ok) throw new Error(`pending gate receipt ${runId} failed integrity: ${verification.reason}`);
+	if (receipt.integrity?.digest === undefined) throw new Error(`pending gate receipt ${runId} has no integrity digest`);
+	return receipt;
+}
+
+function recoveredCorrelation(
+	deps: DispatchToolDeps,
+	subjects: ReadonlyArray<RunGateSubjectRef>,
+	decider: RunReceipt,
+): GateDecisionCorrelation {
+	const first = subjects[0];
+	const subject = first === undefined ? null : readVerifiedGateReceipt(deps, first.runId);
+	if (subject === null) throw new Error("recovered gate decision has no verified subject receipt for correlation");
+	return gateCorrelationOf(subject, decider);
+}
+
+function settlePendingCompeteResource(handle: PendingGateDecisionHandle, draft: GateDecisionDraft): void {
+	if (draft.topology !== "compete" || (draft.outcome !== "winner" && draft.outcome !== "no-winner")) return;
+	const root = handle.record.resourceRoot ?? process.cwd();
+	settleRecoveredCompeteDecision(root, draft.group, draft.outcome === "winner" ? (draft.winner?.index ?? null) : null);
+}
+
+/**
+ * Rebuild decisions whose reviewer/judge output crossed the WAL boundary but
+ * whose coordinator died before parsing or materialization. Receipt integrity
+ * is verified before the output protocol is trusted. Every resolved record is
+ * collision-checked before compete worktrees move to their recovered state.
+ */
+function recoverPendingGateEvidence(deps: DispatchToolDeps): void {
+	const recovery = preparePendingGateDecisionRecovery();
+	const resolved: PendingGateDecisionHandle[] = [];
+	for (const handle of recovery.unresolved) {
+		if (handle.record.kind !== "output") continue;
+		const record = handle.record;
+		const deciderReceipt = readVerifiedGateReceipt(deps, record.deciderRunId);
+		if (deciderReceipt === null) {
+			throw new Error(
+				`pending ${record.topology} decision ${record.id} has no verified decider receipt for ${record.deciderRunId}`,
+			);
+		}
+		const decider = subjectRef(deciderReceipt);
+		let draft: GateDecisionDraft;
+		if (record.topology === "review") {
+			if (isPipelineStepFailure(deciderReceipt)) {
+				draft = {
+					group: record.group,
+					topology: "review",
+					cycle: record.cycle,
+					outcome: "exhausted",
+					subjects: record.subjects,
+					decider,
+					correlation: recoveredCorrelation(deps, record.subjects, deciderReceipt),
+					detail: `reviewer ended ${pipelineFailureReason(deciderReceipt)}`,
+				};
+			} else {
+				draft = decideReviewGate({
+					group: record.group,
+					cycle: record.cycle,
+					terminalCycle: record.terminalCycle === true,
+					subjects: record.subjects,
+					decider,
+					correlation: recoveredCorrelation(deps, record.subjects, deciderReceipt),
+					output: record.finalOutput,
+				}).draft;
+			}
+			resolved.push(resolvePendingGateDecision(handle, draft));
+			continue;
+		}
+
+		const judged = isPipelineStepFailure(deciderReceipt)
+			? null
+			: parseCompeteGateResult(record.finalOutput, record.subjects.length);
+		const pick = judged?.ok ? judged.result.winner : null;
+		const pickedSubject = pick === null ? undefined : record.subjects[pick - 1];
+		const candidateReceipt = pickedSubject === undefined ? null : readVerifiedGateReceipt(deps, pickedSubject.runId);
+		if (pickedSubject !== undefined && candidateReceipt === null) {
+			throw new Error(
+				`pending compete decision ${record.id} has no verified candidate receipt for ${pickedSubject.runId}`,
+			);
+		}
+		let blockedProtected: string[] = [];
+		if (pick !== null && pickedSubject !== undefined && candidateReceipt !== null) {
+			const root = record.resourceRoot ?? process.cwd();
+			const protectedPaths = deps.dispatch.protectedArtifactState?.().artifacts.map((artifact) => artifact.path) ?? [];
+			blockedProtected = protectedPathsChangedByCompeteBranch(
+				root,
+				`clio/compete/${record.group}/${pick}`,
+				protectedPaths,
+			);
+		}
+		const validWinner =
+			pick !== null &&
+			pickedSubject !== undefined &&
+			candidateReceipt !== null &&
+			!isPipelineStepFailure(candidateReceipt) &&
+			blockedProtected.length === 0;
+		if (validWinner && pick !== null && pickedSubject !== undefined) {
+			draft = {
+				group: record.group,
+				topology: "compete",
+				cycle: record.cycle,
+				outcome: "winner",
+				subjects: record.subjects,
+				decider,
+				correlation: recoveredCorrelation(deps, record.subjects, deciderReceipt),
+				winner: {
+					index: pick,
+					subject: pickedSubject,
+					branch: `clio/compete/${record.group}/${pick}`,
+				},
+			};
+		} else {
+			draft = {
+				group: record.group,
+				topology: "compete",
+				cycle: record.cycle,
+				outcome: "no-winner",
+				subjects: record.subjects,
+				decider,
+				correlation: recoveredCorrelation(deps, record.subjects, deciderReceipt),
+				detail: isPipelineStepFailure(deciderReceipt)
+					? `judge ended ${pipelineFailureReason(deciderReceipt)}`
+					: judged !== null && !judged.ok
+						? judged.reason
+						: blockedProtected.length > 0
+							? `judge-selected candidate ${pick} changes protected artifact(s): ${blockedProtected.join(", ")}`
+							: `judge picked failed or missing candidate ${pick}`,
+			};
+		}
+		resolved.push(resolvePendingGateDecision(handle, draft));
+	}
+
+	const ready = [...recovery.ready, ...resolved];
+	preflightPendingGateDecisionMaterialization(ready);
+	for (const handle of ready) {
+		if (handle.record.kind !== "decision") continue;
+		settlePendingCompeteResource(handle, handle.record.decision);
+		materializePendingGateDecision(handle);
+	}
+
+	// A process may have died after the final winner artifact was written but
+	// before the worktree manifest moved to winner-preserved. Restore that safe
+	// decision point even though no pending WAL remains.
+	const durable = readGateDecisionArtifacts();
+	const confirmedGroups = new Set(
+		durable
+			.filter(
+				({ artifact }) =>
+					artifact.topology === "compete" &&
+					(artifact.outcome === "operator-confirmed" || artifact.outcome === "full-auto-applied"),
+			)
+			.map(({ artifact }) => artifact.group),
+	);
+	for (const { artifact } of durable) {
+		if (
+			artifact.topology !== "compete" ||
+			artifact.outcome !== "winner" ||
+			artifact.winner === undefined ||
+			confirmedGroups.has(artifact.group)
+		) {
+			continue;
+		}
+		settleRecoveredCompeteDecision(process.cwd(), artifact.group, artifact.winner.index);
+	}
+}
+
+export interface CompeteSettings {
+	candidates: number;
+	judge?: { agent?: string; model?: string; target?: string; node?: string };
+	/** Immutable per-candidate and judge pins expanded by plan admission. */
+	resolvedTasks?: ReadonlyArray<ResolvedPlanTask>;
+}
+
+const COMPETE_MIN_CANDIDATES = 2;
+const COMPETE_MAX_CANDIDATES = 4;
+
+function competeSettingsFromArgs(
+	args: Record<string, unknown>,
+): { ok: true; compete: CompeteSettings } | { ok: false; message: string } {
+	const raw = args.candidates;
+	let candidates = COMPETE_MIN_CANDIDATES;
+	if (raw !== undefined) {
+		if (
+			typeof raw !== "number" ||
+			!Number.isInteger(raw) ||
+			raw < COMPETE_MIN_CANDIDATES ||
+			raw > COMPETE_MAX_CANDIDATES
+		) {
+			return {
+				ok: false,
+				message: `dispatch: candidates must be an integer ${COMPETE_MIN_CANDIDATES}..${COMPETE_MAX_CANDIDATES}`,
+			};
+		}
+		candidates = raw;
+	}
+	const judgeRaw = args.judge;
+	if (judgeRaw !== undefined && !isRecord(judgeRaw)) {
+		return { ok: false, message: "dispatch: judge must be an options object" };
+	}
+	let judge: CompeteSettings["judge"];
+	if (isRecord(judgeRaw)) {
+		judge = {};
+		const agent = stringArg(judgeRaw, "agent");
+		if (agent !== undefined) judge.agent = agent;
+		const model = stringArg(judgeRaw, "model");
+		if (model !== undefined) judge.model = model;
+		const target = stringArg(judgeRaw, "target");
+		if (target !== undefined) judge.target = target;
+		const node = stringArg(judgeRaw, "node");
+		if (node !== undefined) judge.node = node;
+	}
+	return { ok: true, compete: { candidates, ...(judge !== undefined ? { judge } : {}) } };
+}
+
+interface CompeteOutcome {
+	runs: CompletedRun[];
+	decisions: Array<{ artifact: GateDecisionArtifact; path: string }>;
+	group: string;
+	winner: { index: number; branch: string; applied: boolean } | null;
+	needsDecision?: string;
+	/** Rendered board the candidates and the judge shared, null when empty. */
+	board?: string | null;
+}
+
+interface OwnedCompeteRun {
+	runId: string;
+	settled: boolean;
+	abortRequested: boolean;
+	settlement: Promise<CompletedRun>;
+}
+
+interface CompeteStop {
+	message: string;
+	reason?: AbortReason;
+}
+
+function competeErrorMessage(err: unknown): string {
+	return err instanceof Error ? err.message : String(err);
+}
+
+/**
+ * Prefix the tool name once. Errors raised inside the dispatch domain already
+ * name themselves, and blind prefixing turned those into `dispatch: dispatch:
+ * ...`, which spends the first eleven bytes of a short error saying the same
+ * thing twice.
+ */
+function dispatchErrorMessage(err: unknown): string {
+	const message = competeErrorMessage(err);
+	return message.startsWith("dispatch: ") ? message : `dispatch: ${message}`;
+}
+
+function rejectedReasons(results: ReadonlyArray<PromiseSettledResult<unknown>>): unknown[] {
+	return results
+		.filter((result): result is PromiseRejectedResult => result.status === "rejected")
+		.map((result) => result.reason as unknown);
+}
+
+/**
+ * Best-of-N compete: N candidate builders run the same task in isolated
+ * scratch git worktrees, each candidate's work is committed on its branch, a
+ * read-only judge ranks them, and the winner is applied (full-auto) or handed
+ * to the operator (supervised: the winner's branch and worktree survive; the
+ * apply_winner action routes through plan approval). Losers are always
+ * cleaned, including on abort and on any thrown error.
+ */
+async function runCompete(
+	deps: RegisteredDispatchToolDeps,
+	base: DispatchRequest,
+	compete: CompeteSettings,
+	autonomy: AutonomyLevel,
+	timeoutMs: number | undefined,
+	signal: AbortSignal | undefined,
+): Promise<CompeteOutcome> {
+	const requestedRoot = base.cwd !== undefined && base.cwd.length > 0 ? base.cwd : process.cwd();
+	if (!isGitRepository(requestedRoot)) {
+		throw new Error(`compete requires a git repository at ${requestedRoot}; scratch worktrees isolate the candidates`);
+	}
+	const protectedPaths = deps.dispatch.protectedArtifactState?.().artifacts.map((artifact) => artifact.path) ?? [];
+	// Startup recovery intentionally sweeps only groups that another lifecycle
+	// durably marked cleanup-ready after all of its workers settled. Active,
+	// preserved, and malformed crash leftovers remain untouched.
+	recoverCleanupReadyCompeteGroups(requestedRoot);
+	const group = newGateGroupId("compete");
+	// Candidates run concurrently and the judge reads what they contributed, so
+	// the board reaches the judge with corroboration and dispute labels instead
+	// of only per-candidate output.
+	const ledgerId = newGateGroupId("ledger");
+	const ledger = { id: ledgerId, sequence: 0 };
+	await openAgentLedger(ledgerId);
+	let ownership: CompeteGroupOwnership | null = null;
+	const worktrees: CandidateWorktree[] = [];
+	const runs: CompletedRun[] = [];
+	const decisions: Array<{ artifact: GateDecisionArtifact; path: string }> = [];
+	const recordDecision = (draft: GateDecisionDraft, pending?: PendingGateDecisionHandle) => {
+		const decision = pending
+			? finalizePendingGateDecision(pending, draft)
+			: materializePendingGateDecision(stagePendingGateDecision(draft, { resourceRoot: requestedRoot }));
+		decisions.push(decision);
+		return decision;
+	};
+	const ownedRuns: OwnedCompeteRun[] = [];
+	const abortErrors: unknown[] = [];
+	let stop: CompeteStop | null = null;
+	let primaryError: unknown = null;
+	let winner: CompeteOutcome["winner"] = null;
+	const currentWinner = (): CompeteOutcome["winner"] => winner;
+	let timer: ReturnType<typeof setTimeout> | null = null;
+	let signalListenerInstalled = false;
+
+	const abortOwnedRun = (run: OwnedCompeteRun): void => {
+		if (run.settled || run.abortRequested || stop === null) return;
+		run.abortRequested = true;
+		try {
+			deps.dispatch.abort(run.runId, stop.reason);
+		} catch (err) {
+			abortErrors.push(err);
+		}
+	};
+	const requestStop = (next: CompeteStop): void => {
+		if (stop === null) stop = next;
+		for (const run of ownedRuns) abortOwnedRun(run);
+	};
+	const onSignalAbort = (): void => requestStop({ message: "compete dispatch aborted" });
+	const throwIfStopped = (): void => {
+		if (stop !== null) throw new Error(stop.message);
+	};
+	const settleRun = async (
+		handle: Awaited<ReturnType<DispatchContract["dispatch"]>>,
+		request: DispatchRequest,
+	): Promise<CompletedRun> => {
+		const summaryPromise = consumeGateSensitiveDispatchEvents(deps, handle.runId, request.agentId, handle.events).then(
+			(summary) => {
+				const pendingGate =
+					request.gate?.role === "judge"
+						? stagePendingGateOutput({
+								group: request.gate.group,
+								topology: "compete",
+								cycle: request.gate.cycle,
+								subjects: request.gate.subjects ?? [],
+								deciderRunId: summary.terminalAttemptRunId,
+								finalOutput: normalizedAssistantText(summary),
+								...(request.cwd !== undefined ? { resourceRoot: request.cwd } : {}),
+							})
+						: undefined;
+				return { summary, pendingGate };
+			},
+		);
+		const [summaryResult, receiptResult] = await Promise.allSettled([summaryPromise, handle.finalPromise]);
+		const failures = rejectedReasons([summaryResult, receiptResult]);
+		if (failures.length > 0) {
+			throw new Error(`run ${handle.runId} failed to settle: ${failures.map(competeErrorMessage).join("; ")}`);
+		}
+		const summaryWithGate = summaryResult.status === "fulfilled" ? summaryResult.value : null;
+		const receipt = receiptResult.status === "fulfilled" ? receiptResult.value : null;
+		if (summaryWithGate === null || receipt === null) throw new Error(`run ${handle.runId} produced no settled result`);
+		return completeRun(deps, receipt, summaryWithGate.summary, summaryWithGate.pendingGate);
+	};
+	const admitOwnedRun = async (request: DispatchRequest, label: string): Promise<OwnedCompeteRun> => {
+		try {
+			const handle = await deps.dispatch.dispatch(request, {
+				onAdmitted(admission) {
+					if (ownership === null) throw new Error(`compete ${group} has no active ownership claim`);
+					registerCompeteGroupRun(ownership, admission);
+				},
+			});
+			const owned: OwnedCompeteRun = {
+				runId: handle.runId,
+				settled: false,
+				abortRequested: false,
+				settlement: Promise.resolve(null as never),
+			};
+			ownedRuns.push(owned);
+			owned.settlement = (async () => {
+				try {
+					return await settleRun(handle, request);
+				} catch (err) {
+					requestStop({ message: `${label} failed to settle: ${competeErrorMessage(err)}` });
+					throw err;
+				} finally {
+					owned.settled = true;
+					if (ownership !== null) settleCompeteGroupRun(ownership, owned.runId);
+				}
+			})();
+			// A concurrent admission can fail before this settlement is awaited.
+			// Attach a sink immediately while preserving the original promise for
+			// the transaction's mandatory all-settled barrier.
+			owned.settlement.catch(() => {});
+			if (stop !== null) abortOwnedRun(owned);
+			return owned;
+		} catch (err) {
+			requestStop({ message: `${label} admission failed: ${competeErrorMessage(err)}` });
+			throw err;
+		}
+	};
+	const settledCompletedRuns = async (owned: ReadonlyArray<OwnedCompeteRun>, phase: string): Promise<CompletedRun[]> => {
+		const results = await Promise.allSettled(owned.map((run) => run.settlement));
+		const failures = rejectedReasons(results);
+		if (failures.length > 0) {
+			throw new Error(`${phase} failed: ${failures.map(competeErrorMessage).join("; ")}`);
+		}
+		return results.map((result) => {
+			if (result.status !== "fulfilled") throw new Error(`${phase} produced no completed run`);
+			return result.value;
+		});
+	};
+
+	let outcome: CompeteOutcome | null = null;
+	try {
+		outcome = await (async (): Promise<CompeteOutcome> => {
+			// The owner manifest is the transaction's first group-specific mutation;
+			// every branch and worktree created below is covered by finalization.
+			ownership = claimCompeteGroup(requestedRoot, group);
+			const root = ownership.root;
+			const createCandidate = deps.competeWorktrees?.createCandidate ?? createCandidateWorktree;
+			for (let index = 1; index <= compete.candidates; index += 1) {
+				throwIfStopped();
+				worktrees.push(createCandidate(ownership, index, "HEAD"));
+			}
+
+			if (timeoutMs !== undefined) {
+				timer = setTimeout(
+					() =>
+						requestStop({
+							message: `compete dispatch timed out after ${timeoutMs}ms`,
+							reason: { cause: "timeout", detail: `timed out after ${timeoutMs}ms` },
+						}),
+					timeoutMs,
+				);
+			}
+			signal?.addEventListener("abort", onSignalAbort, { once: true });
+			signalListenerInstalled = signal !== undefined;
+			if (signal?.aborted) onSignalAbort();
+			throwIfStopped();
+
+			// Candidates run concurrently through the normal per-run admission path;
+			// every admission promise is observed to settlement. The first rejection
+			// aborts known siblings, and any sibling accepted later sees `stop` and is
+			// aborted before it can escape the transaction.
+			const admissionResults = await Promise.allSettled(
+				worktrees.map((worktree) => {
+					const request: DispatchRequest = {
+						...base,
+						executionRole: "builder",
+						cwd: worktree.path,
+						protectedArtifactRemap: { sourceRoot: root, workerRoot: worktree.path },
+						gate: { role: "candidate", group, cycle: worktree.index },
+						ledger,
+						competeStance: COMPETE_STANCES[(worktree.index - 1) % COMPETE_STANCES.length] as CompeteStance,
+					};
+					return admitOwnedRun(
+						withResolvedPlanTaskPin(
+							request,
+							compete.resolvedTasks?.find((task) => task.role === "candidate" && task.position === worktree.index),
+						),
+						`candidate ${worktree.index}`,
+					);
+				}),
+			);
+			const admissionFailures = rejectedReasons(admissionResults);
+			if (admissionFailures.length > 0) {
+				const admissionMessage = `compete candidate admission failed: ${admissionFailures
+					.map(competeErrorMessage)
+					.join("; ")}`;
+				requestStop({ message: admissionMessage });
+				// All admission promises have now settled, including late accepts. Wait
+				// for every accepted run before finalization removes any path.
+				await Promise.allSettled(ownedRuns.map((run) => run.settlement));
+				throw new Error(admissionMessage);
+			}
+			const candidateOwned = admissionResults.map((result) => {
+				if (result.status !== "fulfilled") throw new Error("compete candidate admission produced no handle");
+				return result.value;
+			});
+			const candidateRuns = await settledCompletedRuns(candidateOwned, "candidate settlement");
+			runs.push(...candidateRuns);
+			throwIfStopped();
+			const stats = worktrees.map((worktree, index) => {
+				const receipt = candidateRuns[index]?.receipt;
+				const failed = receipt !== undefined && isPipelineStepFailure(receipt);
+				if (failed) return "builder failed";
+				commitCandidateWork(worktree, `clio-coder compete ${group} candidate ${worktree.index}`);
+				return candidateDiffStat(root, worktree.branch);
+			});
+			if (candidateRuns.every((run) => isPipelineStepFailure(run.receipt))) {
+				recordDecision({
+					group,
+					topology: "compete",
+					cycle: 1,
+					outcome: "no-winner",
+					subjects: candidateRuns.map((run) => subjectRef(run.receipt)),
+					detail: "every candidate builder failed; nothing to judge",
+				});
+				return { runs, decisions, group, winner: null, needsDecision: "every candidate builder failed; nothing to judge" };
+			}
+			const judgeRequest: DispatchRequest = {
+				agentId: gateDeciderAgentId(compete.judge?.agent),
+				executionRole: "judge",
+				task: judgeTask(base.task, worktrees, stats),
+				systemPrompt: JUDGE_GATE_PROMPT,
+				autonomy: "read-only",
+				cwd: root,
+				gate: {
+					role: "judge",
+					group,
+					cycle: 1,
+					subjects: candidateRuns.map((run) => subjectRef(run.receipt)),
+				},
+				ledger,
+				...(compete.judge?.model !== undefined ? { model: compete.judge.model } : {}),
+				...(compete.judge?.target !== undefined ? { target: compete.judge.target } : {}),
+				...(compete.judge?.node !== undefined ? { node: compete.judge.node } : {}),
+				...(base.plan !== undefined ? { plan: base.plan } : {}),
+				...(base.parentToolCallId !== undefined ? { parentToolCallId: base.parentToolCallId } : {}),
+				...(base.reservation !== undefined
+					? { reservation: { ownerId: base.reservation.ownerId, memberId: base.reservation.memberId } }
+					: {}),
+			};
+			throwIfStopped();
+			const judgeOwned = await admitOwnedRun(
+				withResolvedPlanTaskPin(
+					judgeRequest,
+					compete.resolvedTasks?.find((task) => task.role === "judge"),
+					{ pinTask: false },
+				),
+				"judge",
+			);
+			const judgeRun = (await settledCompletedRuns([judgeOwned], "judge settlement"))[0];
+			if (judgeRun === undefined) throw new Error("judge produced no completed run");
+			runs.push(judgeRun);
+			throwIfStopped();
+			const judgeReceipt = judgeRun.receipt;
+			const judgeSummary = judgeRun.summary;
+			// Every judged outcome names the same subjects, decider, and correlation;
+			// only the reason the gate produced no applicable winner differs.
+			const noWinner = (detail: string): GateDecisionDraft => ({
+				group,
+				topology: "compete",
+				cycle: 1,
+				outcome: "no-winner",
+				subjects: candidateRuns.map((run) => subjectRef(run.receipt)),
+				decider: subjectRef(judgeReceipt),
+				correlation: competeCorrelation(candidateRuns, judgeReceipt),
+				detail,
+			});
+			if (isPipelineStepFailure(judgeReceipt)) {
+				recordDecision(noWinner(`judge ended ${pipelineFailureReason(judgeReceipt)}`), judgeRun.pendingGate);
+				return {
+					runs,
+					decisions,
+					group,
+					winner: null,
+					needsDecision: `judge run ${judgeReceipt.runId} ended ${pipelineFailureReason(judgeReceipt)}; candidate worktrees were cleaned, their receipts remain; re-run compete or build directly`,
+				};
+			}
+			const judged = parseCompeteGateResult(normalizedAssistantText(judgeSummary), compete.candidates);
+			if (!judged.ok) {
+				recordDecision(noWinner(judged.reason), judgeRun.pendingGate);
+				return {
+					runs,
+					decisions,
+					group,
+					winner: null,
+					needsDecision: `${judged.reason}; candidate worktrees were cleaned, their receipts remain; re-run compete or build directly`,
+				};
+			}
+			const pick = judged.result.winner;
+			const pickedWorktree = worktrees.find((worktree) => worktree.index === pick);
+			const pickedRun = candidateRuns[pick - 1];
+			if (!pickedWorktree || pickedRun === undefined || isPipelineStepFailure(pickedRun.receipt)) {
+				recordDecision(noWinner(`judge picked failed or missing candidate ${pick}`), judgeRun.pendingGate);
+				return {
+					runs,
+					decisions,
+					group,
+					winner: null,
+					needsDecision: `judge picked candidate ${pick}, whose builder failed; the operator decides`,
+				};
+			}
+			const protectedChanges = protectedPathsChangedByCompeteBranch(root, pickedWorktree.branch, protectedPaths);
+			if (protectedChanges.length > 0) {
+				recordDecision(
+					noWinner(`judge-selected candidate ${pick} changes protected artifact(s): ${protectedChanges.join(", ")}`),
+					judgeRun.pendingGate,
+				);
+				return {
+					runs,
+					decisions,
+					group,
+					winner: null,
+					needsDecision: `candidate ${pick} changes protected artifact(s) and cannot be applied: ${protectedChanges.join(", ")}`,
+				};
+			}
+			const winnerRef = {
+				index: pick,
+				subject: subjectRef(pickedRun.receipt),
+				branch: pickedWorktree.branch,
+			};
+			const winnerDecision = recordDecision(
+				{
+					group,
+					topology: "compete",
+					cycle: 1,
+					outcome: "winner",
+					subjects: candidateRuns.map((run) => subjectRef(run.receipt)),
+					decider: subjectRef(judgeReceipt),
+					correlation: competeCorrelation(candidateRuns, judgeReceipt),
+					winner: winnerRef,
+				},
+				judgeRun.pendingGate,
+			);
+			if (autonomy === "full-auto") {
+				const merge = (deps.competeWorktrees?.mergeWinner ?? mergeWinnerBranch)(root, pickedWorktree.branch);
+				if (!merge.ok) {
+					winner = { index: pick, branch: pickedWorktree.branch, applied: false };
+					return {
+						runs,
+						decisions,
+						group,
+						winner,
+						needsDecision: `winner candidate ${pick} could not be merged (${merge.reason}); its branch ${pickedWorktree.branch} is preserved`,
+					};
+				}
+				try {
+					recordDecision({
+						group,
+						topology: "compete",
+						cycle: 1,
+						outcome: "full-auto-applied",
+						subjects: [winnerRef.subject],
+						winner: winnerRef,
+						confirmation: {
+							id: winnerDecision.artifact.id,
+							digest: winnerDecision.artifact.integrity.digest,
+						},
+						detail: `full-auto applied ${pickedWorktree.branch} under dispatch plan ${base.plan?.hash ?? "unavailable"}`,
+					});
+				} catch (error) {
+					winner = { index: pick, branch: pickedWorktree.branch, applied: false };
+					throw new Error(
+						`winner ${pickedWorktree.branch} merged but full-auto application evidence failed: ${competeErrorMessage(error)}; branch preserved for recovery`,
+					);
+				}
+				winner = { index: pick, branch: pickedWorktree.branch, applied: true };
+				return { runs, decisions, group, winner };
+			}
+			winner = { index: pick, branch: pickedWorktree.branch, applied: false };
+			return { runs, decisions, group, winner };
+		})();
+	} catch (err) {
+		primaryError = err;
+	}
+	if (timer) clearTimeout(timer);
+	if (signalListenerInstalled) signal?.removeEventListener("abort", onSignalAbort);
+
+	// No path may be removed while a worker can still write through it. On
+	// every exceptional exit, abort all accepted runs (including late
+	// admissions) and await the settlement promise that drains both events
+	// and final receipt completion.
+	if (ownedRuns.some((run) => !run.settled)) {
+		requestStop({ message: "compete lifecycle exited before every worker settled" });
+	}
+	const finalizationErrors: unknown[] = [];
+	await Promise.allSettled(ownedRuns.map((run) => run.settlement));
+	// Every worker has settled, so no further post can be admitted. The board is
+	// read here, on the way past, for the model that started the compete.
+	const board = renderAgentLedgerBoard(ledgerId);
+	await closeAgentLedger(ledgerId);
+	finalizationErrors.push(...abortErrors);
+
+	// Losers are always cleaned; the winner's worktree and branch survive
+	// only while an operator decision is pending (supervised pick or a
+	// failed merge). The durable state transition happens after the worker
+	// barrier and before deletion, defining the safe restart boundary.
+	const winnerAtFinalization = currentWinner();
+	if (ownership !== null) {
+		if (winnerAtFinalization !== null && !winnerAtFinalization.applied) {
+			try {
+				ownership = markCompeteGroupWinnerPreserved(ownership, winnerAtFinalization.index);
+				for (const worktree of worktrees) {
+					if (worktree.index === winnerAtFinalization.index) continue;
+					try {
+						removeCandidateWorktree(ownership, worktree, true);
+					} catch (err) {
+						finalizationErrors.push(err);
+					}
+				}
+			} catch (err) {
+				// Without the preserved-state record, retain every candidate; a
+				// later process must not guess which path is safe to remove.
+				finalizationErrors.push(err);
+			}
+		} else {
+			try {
+				ownership = markCompeteGroupCleanupReady(ownership);
+			} catch (err) {
+				finalizationErrors.push(err);
+			}
+			try {
+				const cleanupGroup = deps.competeWorktrees?.cleanupGroup ?? cleanupCompeteGroup;
+				cleanupGroup(ownership);
+			} catch (err) {
+				finalizationErrors.push(err);
+			}
+		}
+	}
+
+	if (finalizationErrors.length > 0) {
+		const unique = [...new Set(finalizationErrors)];
+		const suffix = unique.map(competeErrorMessage).join("; ");
+		if (primaryError !== null) {
+			throw new Error(`${competeErrorMessage(primaryError)}; compete finalization also failed: ${suffix}`);
+		}
+		throw new Error(`compete finalization failed: ${suffix}`);
+	}
+	if (primaryError !== null) throw primaryError;
+	if (outcome === null) throw new Error("compete lifecycle produced no outcome");
+	return { ...outcome, board };
+}
+
+/**
+ * Apply a preserved compete winner. Plan-scale by definition, so supervised
+ * autonomy levels park this call for operator confirmation; the approval IS
+ * the winner confirmation. After a successful merge the whole compete group
+ * is cleaned up.
+ */
+function runApplyWinner(
+	args: Record<string, unknown>,
+	authority:
+		| { outcome: "operator-confirmed"; requestId: string; requestedBy: string }
+		| { outcome: "full-auto-applied" }
+		| null,
+	mergeWinner: typeof mergeWinnerBranch = mergeWinnerBranch,
+	protectedPaths: ReadonlyArray<string> = [],
+): ToolResult {
+	if (authority === null) {
+		return {
+			kind: "error",
+			message: "dispatch: apply_winner requires a registry-authenticated operator approval or full-auto authority",
+		};
+	}
+	const raw = args.apply_winner;
+	if (!isRecord(raw)) return { kind: "error", message: "dispatch: apply_winner must be an options object" };
+	const branch = stringArg(raw, "branch");
+	if (!branch) return { kind: "error", message: "dispatch: apply_winner.branch is required" };
+	const match = /^clio\/compete\/([A-Za-z0-9][A-Za-z0-9._-]{0,127})\/([1-9]\d*)$/.exec(branch);
+	if (!match) {
+		return { kind: "error", message: "dispatch: apply_winner.branch must be a clio/compete/<group>/<n> branch" };
+	}
+	const group = match[1] ?? "";
+	const winnerIndex = Number.parseInt(match[2] ?? "", 10);
+	const root = stringArg(raw, "cwd") ?? process.cwd();
+	if (!isGitRepository(root)) {
+		return { kind: "error", message: `dispatch: apply_winner requires a git repository at ${root}` };
+	}
+	recoverCleanupReadyCompeteGroups(root);
+	const ownership = loadCompeteGroup(root, group);
+	if (ownership === null) {
+		return {
+			kind: "error",
+			message: `dispatch: winner branch ${branch} has no matching compete ownership manifest; refusing to merge or delete unproven state`,
+		};
+	}
+	if (ownership.state !== "winner-preserved" || ownership.winnerIndex !== winnerIndex) {
+		return {
+			kind: "error",
+			message: `dispatch: winner branch ${branch} does not match the preserved winner recorded for compete group ${group}`,
+		};
+	}
+	const winnerDecision = readGateDecisionArtifacts(group)
+		.filter(
+			(entry) =>
+				entry.artifact.outcome === "winner" &&
+				entry.artifact.winner?.index === winnerIndex &&
+				entry.artifact.winner.branch === branch,
+		)
+		.sort(
+			(left, right) =>
+				left.artifact.createdAt.localeCompare(right.artifact.createdAt) ||
+				left.artifact.id.localeCompare(right.artifact.id),
+		)
+		.at(-1);
+	if (winnerDecision === undefined || winnerDecision.artifact.winner === undefined) {
+		return {
+			kind: "error",
+			message: `dispatch: winner branch ${branch} has no integrity-valid judge decision; refusing an unauditable confirmation`,
+		};
+	}
+	const winnerRef = winnerDecision.artifact.winner;
+	const protectedChanges = protectedPathsChangedByCompeteBranch(root, branch, protectedPaths);
+	if (protectedChanges.length > 0) {
+		return {
+			kind: "error",
+			message: `dispatch: winner branch ${branch} changes protected artifact(s) and cannot be merged: ${protectedChanges.join(", ")}`,
+		};
+	}
+	const writeConfirmation = (): { artifact: GateDecisionArtifact; path: string } =>
+		materializePendingGateDecision(
+			stagePendingGateDecision({
+				group,
+				topology: "compete",
+				cycle: 1,
+				outcome: authority.outcome,
+				subjects: [winnerRef.subject],
+				winner: winnerRef,
+				confirmation: {
+					id: winnerDecision.artifact.id,
+					digest: winnerDecision.artifact.integrity.digest,
+				},
+				detail:
+					authority.outcome === "operator-confirmed"
+						? `operator confirmation ${authority.requestId} (${authority.requestedBy}) approved ${branch} under dispatch plan ${describeDispatchPlan(args).hash}`
+						: `full-auto applied ${branch} under dispatch plan ${describeDispatchPlan(args).hash}`,
+			}),
+		);
+	let confirmation: { artifact: GateDecisionArtifact; path: string } | null = null;
+	if (authority.outcome === "operator-confirmed") {
+		try {
+			confirmation = writeConfirmation();
+		} catch (err) {
+			return {
+				kind: "error",
+				message: `dispatch: could not persist operator confirmation for ${branch}: ${competeErrorMessage(err)}`,
+			};
+		}
+	}
+	const merge = mergeWinner(root, branch);
+	if (!merge.ok) {
+		return {
+			kind: "error",
+			message: `dispatch: winner branch ${branch} could not be merged: ${merge.reason}; the branch is preserved`,
+			...(confirmation !== null
+				? { details: { confirmationPath: confirmation.path, confirmationId: confirmation.artifact.id } }
+				: {}),
+		};
+	}
+	if (authority.outcome === "full-auto-applied") {
+		try {
+			confirmation = writeConfirmation();
+		} catch (err) {
+			return {
+				kind: "error",
+				message: `dispatch: winner branch ${branch} was merged, but full-auto application evidence failed: ${competeErrorMessage(err)}; branch is preserved for recovery`,
+				details: { mode: "apply_winner", branch, group, applied: true, evidencePending: true },
+			};
+		}
+	}
+	if (confirmation === null) {
+		return { kind: "error", message: `dispatch: winner branch ${branch} was merged without confirmation evidence` };
+	}
+	try {
+		const cleanupOwnership = markCompeteGroupCleanupReady(ownership);
+		cleanupCompeteGroup(cleanupOwnership);
+	} catch (err) {
+		return {
+			kind: "error",
+			message: `dispatch: winner branch ${branch} was merged, but compete cleanup failed: ${competeErrorMessage(err)}`,
+			details: {
+				mode: "apply_winner",
+				branch,
+				group,
+				applied: true,
+				cleanupPending: true,
+				confirmationPath: confirmation.path,
+				confirmationId: confirmation.artifact.id,
+			},
+		};
+	}
+	return {
+		kind: "ok",
+		output: `winner ${branch} merged into the current branch; compete group ${group} cleaned up`,
+		details: {
+			mode: "apply_winner",
+			branch,
+			group,
+			confirmationPath: confirmation.path,
+			confirmationId: confirmation.artifact.id,
+		},
+	};
+}
+
+function reviewGateResult(deps: DispatchToolDeps, outcome: GateRunOutcome, maxOutputBytes: number): ToolResult {
+	const body = formatDispatchOutput("review", outcome.runs, maxOutputBytes);
+	const details: ToolResultDetails = {
+		...dispatchDetails(deps, "review", outcome.runs),
+		gate: {
+			verdict: outcome.verdict,
+			cycles: outcome.cycles,
+			decisions: outcome.decisions.map(({ artifact, path }) => ({
+				id: artifact.id,
+				outcome: artifact.outcome,
+				path,
+				digest: artifact.integrity.digest,
+			})),
+			...(outcome.needsDecision !== undefined ? { needsDecision: outcome.needsDecision } : {}),
+		},
+	};
+	if (outcome.verdict === "pass") {
+		return { kind: "ok", output: `review gate passed after ${outcome.cycles} cycle(s)\n\n${body}`, details };
+	}
+	if (outcome.verdict === "fail") {
+		return { kind: "error", message: `dispatch: review gate failed (reviewer verdict fail)\n\n${body}`, details };
+	}
+	return {
+		kind: "error",
+		message: `dispatch: review gate needs an operator decision: ${outcome.needsDecision ?? "no verdict"}\n\n${body}`,
+		details,
+	};
+}
+
+function competeResult(
+	deps: DispatchToolDeps,
+	outcome: CompeteOutcome,
+	autonomy: AutonomyLevel,
+	maxOutputBytes: number,
+): ToolResult {
+	const board = outcome.board ?? null;
+	const body = formatDispatchOutput("compete", outcome.runs, maxOutputBytes, board);
+	const details: ToolResultDetails = {
+		...dispatchDetails(deps, "compete", outcome.runs, board),
+		compete: {
+			group: outcome.group,
+			winner: outcome.winner,
+			decisions: outcome.decisions.map(({ artifact, path }) => ({
+				id: artifact.id,
+				outcome: artifact.outcome,
+				path,
+				digest: artifact.integrity.digest,
+			})),
+			...(outcome.needsDecision !== undefined ? { needsDecision: outcome.needsDecision } : {}),
+		},
+	};
+	if (outcome.winner?.applied === true) {
+		return {
+			kind: "ok",
+			output: `compete winner candidate ${outcome.winner.index} applied (branch ${outcome.winner.branch} merged)\n\n${body}`,
+			details,
+		};
+	}
+	if (outcome.winner !== null && outcome.needsDecision === undefined) {
+		const lines = [
+			`compete winner: candidate ${outcome.winner.index} (branch ${outcome.winner.branch}), preserved for confirmation at autonomy ${autonomy}`,
+			`Apply it with dispatch apply_winner={branch: "${outcome.winner.branch}"}; the approval prompt is the winner confirmation. Losing candidates were cleaned up.`,
+		];
+		return { kind: "ok", output: `${lines.join("\n")}\n\n${body}`, details };
+	}
+	return {
+		kind: "error",
+		message: `dispatch: compete needs an operator decision: ${outcome.needsDecision ?? "no winner"}\n\n${body}`,
+		details,
+	};
+}
+
+export function createDispatchTool(inputDeps: DispatchToolDeps): ToolSpec {
+	const deps: RegisteredDispatchToolDeps = {
+		...inputDeps,
+		runEvents: inputDeps.runEvents ?? createDispatchRunEventRegistry(),
+	};
+	// A model can supply arbitrary JSON properties even when the schema omits
+	// them. Trust resolved artifacts only when this exact tool instance created
+	// the argument object at admission; a forged hidden field is stripped and
+	// recomputed. Parked calls retain object identity, so approval and execution
+	// consume the same immutable resolution even if settings/capacity drift.
+	const preparedAdmissionArgs = new WeakSet<Record<string, unknown>>();
+	const trustedResolvedPlans = new WeakMap<Record<string, unknown>, ResolvedDispatchPlanArtifact>();
+	const trustedReservationOwners = new WeakMap<Record<string, unknown>, string>();
+	const trustedParsedRequests = new WeakMap<Record<string, unknown>, ReadonlyArray<DispatchRequest>>();
+	const trustedExecutionPlans = new WeakMap<Record<string, unknown>, ExecutionPlan>();
+	const taskResolutions = new WeakMap<object, DispatchPlanTaskResolution>();
+	const deepFreeze = <T>(value: T): T => {
+		if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
+		for (const child of Object.values(value)) deepFreeze(child);
+		return Object.freeze(value);
+	};
+	const parseRequests = (args: Record<string, unknown>) =>
+		dispatchRequestsFromArgs(args, {
+			...(deps.getAgentRoleFacts ? { resolveFacts: deps.getAgentRoleFacts } : {}),
+			hasAgent: (id) => deps.getAgentSpecs().some((spec) => spec.id === id),
+			auto: {
+				approvedAuthorities: ["read-only", "verification", "artifact-write", "workspace-edit"],
+				authorityBasis: deps.getAutonomy?.() === "full-auto" ? "full-auto-policy" : "operator-plan-approval",
+			},
+		});
+	const trustRequests = (args: Record<string, unknown>, requests: ReadonlyArray<DispatchRequest>) => {
+		trustedParsedRequests.set(args, deepFreeze(structuredClone(requests)));
+		return args;
+	};
+	const markPrepared = (args: Record<string, unknown>): Record<string, unknown> => {
+		const exposed = resolvedDispatchPlanFromArgs(args);
+		if (exposed !== null) {
+			// The WeakMap snapshot is the execution authority. The separately
+			// cloned/frozen hidden value remains available to generic registry policy
+			// rendering, but cannot be mutated or replaced after preparation.
+			const trusted = deepFreeze(structuredClone(exposed));
+			const policyView = deepFreeze(structuredClone(exposed));
+			trustedResolvedPlans.set(args, trusted);
+			Object.defineProperty(args, RESOLVED_DISPATCH_PLAN_ARGUMENT, {
+				value: policyView,
+				enumerable: true,
+				configurable: false,
+				writable: false,
+			});
+		}
+		preparedAdmissionArgs.add(args);
+		return args;
+	};
+	const stripUntrustedPlanFields = (rawArgs: Record<string, unknown>): Record<string, unknown> => {
+		const normalized = prepareDispatchArguments(rawArgs);
+		const clean = { ...normalized };
+		Reflect.deleteProperty(clean, RESOLVED_DISPATCH_PLAN_ARGUMENT);
+		Reflect.deleteProperty(clean, DISPATCH_PLAN_PREPARATION_ERROR_ARGUMENT);
+		return clean;
+	};
+	const preparationFailure = (args: Record<string, unknown>, err: unknown): Record<string, unknown> =>
+		markPrepared({
+			...args,
+			[DISPATCH_PLAN_PREPARATION_ERROR_ARGUMENT]: err instanceof Error ? err.message : String(err),
+		});
+	// A call whose shape the executor will refuse must not reach the operator
+	// as an approvable plan. Marking it prepared without a plan would render a
+	// plan-scale card from the raw arguments, and the approved call would then
+	// die on "resolved plan is missing after admission" instead of the real
+	// shape error. Recording the executor's own message as the preparation
+	// failure keeps the card away and hands the model the actionable text.
+	const shapeRejection = (args: Record<string, unknown>, message: string): Record<string, unknown> =>
+		describeDispatchPlan(args).planScale ? preparationFailure(args, message) : markPrepared(args);
+	const resolveTask = (
+		request: DispatchRequest,
+		role: NonNullable<ResolvedDispatchPlanArtifact["tasks"][number]["role"]>,
+		position: number,
+	): ResolvedDispatchPlanArtifact["tasks"][number] => {
+		const resolution = deps.dispatch.preview?.(request);
+		if (resolution === undefined) throw new Error("dispatch preview is unavailable");
+		// An approved exact route and automatic failover are semantically opposed,
+		// so a planned task is never "automatic". An explicit pin seals that exact
+		// tuple with no failover; anything else seals a bounded envelope the
+		// operator saw. The plan hash covers the rendered candidate list, so
+		// distinct envelopes get distinct hashes.
+		const pinned = request.node !== undefined || request.target !== undefined || request.model !== undefined;
+		const approvedCandidates =
+			pinned || request.failover !== "approved"
+				? []
+				: resolution.routeApproval === null
+					? (deps.dispatch.routeCandidates?.(request) ?? [])
+					: approvedRouteCandidates(resolution.routeApproval);
+		const failover: DispatchFailoverMode = pinned || approvedCandidates.length === 0 ? "none" : "approved";
+		const task: ResolvedDispatchPlanArtifact["tasks"][number] = {
+			agent: resolution.agentId,
+			task: request.task,
+			...(request.briefing !== undefined ? { briefing: request.briefing } : {}),
+			target: resolution.targetId,
+			model: resolution.wireModelId,
+			node: resolution.node.id,
+			nodeKind: resolution.node.kind,
+			...(resolution.node.host !== undefined ? { nodeHost: resolution.node.host } : {}),
+			routingIntent: request.routingIntent ?? defaultRoutingIntent(request),
+			failover,
+			routeApproval: resolution.routeApproval,
+			agentSelection: request.agentSelection === undefined ? null : structuredClone(request.agentSelection),
+			stepId: null,
+			dependencies: [],
+			executionRole: request.executionRole,
+			expectedResultContract: null,
+			authorityGrant: null,
+			agentDecision: null,
+			wave: null,
+			...(failover === "approved" ? { allowedCandidates: approvedCandidates.map((candidate) => ({ ...candidate })) } : {}),
+			role,
+			position,
+		};
+		taskResolutions.set(task, resolution);
+		return task;
+	};
+	const resolvedCostCeiling = (): number => {
+		const injected = deps.getCostCeilingUsd?.();
+		if (injected !== undefined && Number.isFinite(injected) && injected > 0) return injected;
+		const ceiling = deps.dispatch.costCeilingUsd?.();
+		if (ceiling === undefined || !Number.isFinite(ceiling) || ceiling <= 0) {
+			throw new Error("dispatch scheduling cost ceiling is unavailable");
+		}
+		return ceiling;
+	};
+	const reservationWave = (
+		topology: ResolvedDispatchPlanArtifact["topology"],
+		task: ResolvedDispatchPlanArtifact["tasks"][number],
+		index: number,
+	): number => {
+		if (topology === "fleet") return task.wave ?? index;
+		if (topology === "parallel" || topology === "detached") return 0;
+		if (topology === "compete") return task.role === "judge" ? 1 : 0;
+		return index;
+	};
+	const markReservedPlan = (
+		args: Record<string, unknown>,
+		artifact: ResolvedDispatchPlanArtifact,
+	): Record<string, unknown> => {
+		const prepared = withResolvedDispatchPlan(args, artifact);
+		if (deps.dispatch.reservations === undefined) return markPrepared(prepared);
+		const tasks = artifact.tasks.map((task, index) => {
+			const resolution = taskResolutions.get(task);
+			if (resolution === undefined || (task.stepId === null && (task.role === undefined || task.position === undefined))) {
+				throw new Error("dispatch reservation resolution is incomplete");
+			}
+			return {
+				memberId: task.stepId ?? `${task.role}-${task.position}`,
+				wave: reservationWave(artifact.topology, task, index),
+				resolution,
+			};
+		});
+		const reservation = deps.dispatch.reservations.prepare({
+			topology: artifact.topology === "fleet" ? "parallel" : artifact.topology,
+			tasks,
+		});
+		try {
+			const marked = markPrepared(prepared);
+			trustedReservationOwners.set(marked, reservation.ownerId);
+			return marked;
+		} catch (error) {
+			deps.dispatch.reservations.rollback(reservation.ownerId);
+			throw error;
+		}
+	};
+	const prepareAdmissionArguments = (rawArgs: Record<string, unknown>): Record<string, unknown> => {
+		const args = stripUntrustedPlanFields(rawArgs);
+		if (args.list === true) return markPrepared(args);
+		const continuation = scoutContinuationRefFromArgs(args);
+		if (!continuation.ok) return preparationFailure(args, continuation.message);
+		if (continuation.ref !== null) {
+			try {
+				const source = loadVerifiedScoutSource({
+					ref: continuation.ref,
+					dispatch: deps.dispatch,
+					agentSpecs: deps.getAgentSpecs(),
+				});
+				const prepared = prepareScoutContinuation({
+					source,
+					authorization: deps.getAutonomy?.() === "full-auto" ? "full-auto-policy" : "operator-plan-approval",
+					planAgentSelection: deps.dispatch.planAgentSelection,
+					costCeilingUsd: resolvedCostCeiling(),
+				});
+				for (const [index, task] of prepared.artifact.tasks.entries()) {
+					const resolution = prepared.resolutions[index];
+					if (resolution === undefined) throw new Error("dispatch: Scout route resolution is incomplete");
+					taskResolutions.set(task, resolution);
+				}
+				const marked = trustRequests(markReservedPlan(args, prepared.artifact), prepared.requests);
+				trustedExecutionPlans.set(marked, deepFreeze(structuredClone(prepared.executionPlan)));
+				return marked;
+			} catch (error) {
+				return preparationFailure(args, error);
+			}
+		}
+		if (args.apply_winner !== undefined) {
+			if (!isRecord(args.apply_winner)) return markPrepared(args);
+			const branch = stringArg(args.apply_winner, "branch");
+			const match = branch ? /^clio\/compete\/([A-Za-z0-9][A-Za-z0-9._-]{0,127})\/([1-9]\d*)$/.exec(branch) : null;
+			if (branch === undefined || match === null) return markPrepared(args);
+			if (deps.getCostCeilingUsd === undefined && deps.dispatch.costCeilingUsd === undefined) return markPrepared(args);
+			try {
+				return markPrepared(
+					withResolvedDispatchPlan(args, {
+						version: 3,
+						topology: "compete",
+						source: null,
+						maxWorkers: null,
+						onFailure: null,
+						tasks: [],
+						costCeilingUsd: resolvedCostCeiling(),
+						deadlineMs: null,
+						confirmation: {
+							branch,
+							group: match[1] ?? "",
+							index: Number.parseInt(match[2] ?? "", 10),
+						},
+					}),
+				);
+			} catch (err) {
+				return preparationFailure(args, err);
+			}
+		}
+		if (deps.dispatch.preview === undefined) return markPrepared(args);
+		const parsed = parseRequests(args);
+		if (!parsed.ok) return shapeRejection(args, parsed.message);
+		if (args.mode !== undefined && !["parallel", "sequential", "pipeline", "compete"].includes(String(args.mode))) {
+			return shapeRejection(
+				args,
+				`dispatch: mode must be parallel, sequential, pipeline, or compete; got '${String(args.mode)}'`,
+			);
+		}
+		const mode =
+			args.mode === "sequential"
+				? "sequential"
+				: args.mode === "pipeline"
+					? "pipeline"
+					: args.mode === "compete"
+						? "compete"
+						: "parallel";
+		try {
+			const tasks: ResolvedDispatchPlanArtifact["tasks"] = [];
+			const reviewResult = reviewSettingsFromArgs(args);
+			if (!reviewResult.ok) return shapeRejection(args, reviewResult.message);
+			if (reviewResult.review !== undefined) {
+				if (mode === "compete") return shapeRejection(args, COMPETE_NO_REVIEW_MESSAGE);
+				if (mode !== "parallel") return shapeRejection(args, `dispatch: review does not combine with mode=${mode}`);
+				if (parsed.requests.length !== 1 || parsed.requests[0] === undefined) {
+					return shapeRejection(args, REVIEW_SINGLE_TASK_MESSAGE);
+				}
+				const base = parsed.requests[0];
+				for (let cycle = 1; cycle <= reviewResult.review.maxCycles; cycle += 1) {
+					const builderSubject: RunGateSubjectRef = { runId: `plan-builder-${cycle}`, digest: null };
+					tasks.push(
+						resolveTask(
+							{ ...base, executionRole: "builder", gate: { role: "builder", group: "plan-preview", cycle } },
+							"builder",
+							cycle,
+						),
+					);
+					tasks.push(
+						resolveTask(
+							{
+								agentId: gateDeciderAgentId(reviewResult.review.reviewer),
+								executionRole: "reviewer",
+								task: reviewerTask(base.task, builderSubject.runId, cycle),
+								systemPrompt: REVIEWER_GATE_PROMPT,
+								autonomy: "read-only",
+								gate: { role: "reviewer", group: "plan-preview", cycle, subjects: [builderSubject] },
+								...(base.cwd !== undefined ? { cwd: base.cwd } : {}),
+								...(reviewResult.review.node !== undefined ? { node: reviewResult.review.node } : {}),
+								...(reviewResult.review.model !== undefined ? { model: reviewResult.review.model } : {}),
+								...(reviewResult.review.target !== undefined ? { target: reviewResult.review.target } : {}),
+							},
+							"reviewer",
+							cycle,
+						),
+					);
+				}
+			} else if (mode === "compete") {
+				if (parsed.requests.length !== 1 || parsed.requests[0] === undefined) {
+					return shapeRejection(args, COMPETE_SINGLE_TASK_MESSAGE);
+				}
+				const competeResult = competeSettingsFromArgs(args);
+				if (!competeResult.ok) return shapeRejection(args, competeResult.message);
+				const base = parsed.requests[0];
+				const subjects: RunGateSubjectRef[] = [];
+				for (let candidate = 1; candidate <= competeResult.compete.candidates; candidate += 1) {
+					subjects.push({ runId: `plan-candidate-${candidate}`, digest: null });
+					tasks.push(
+						resolveTask(
+							{ ...base, executionRole: "builder", gate: { role: "candidate", group: "plan-preview", cycle: candidate } },
+							"candidate",
+							candidate,
+						),
+					);
+				}
+				tasks.push(
+					resolveTask(
+						{
+							agentId: gateDeciderAgentId(competeResult.compete.judge?.agent),
+							executionRole: "judge",
+							task: `Plan-time capability check for the ${competeResult.compete.candidates}-candidate judge.`,
+							systemPrompt: JUDGE_GATE_PROMPT,
+							autonomy: "read-only",
+							gate: { role: "judge", group: "plan-preview", cycle: 1, subjects },
+							...(base.cwd !== undefined ? { cwd: base.cwd } : {}),
+							...(competeResult.compete.judge?.node !== undefined ? { node: competeResult.compete.judge.node } : {}),
+							...(competeResult.compete.judge?.model !== undefined ? { model: competeResult.compete.judge.model } : {}),
+							...(competeResult.compete.judge?.target !== undefined ? { target: competeResult.compete.judge.target } : {}),
+						},
+						"judge",
+						1,
+					),
+				);
+			} else {
+				for (const [index, request] of parsed.requests.entries()) {
+					tasks.push(resolveTask(request, "task", index + 1));
+				}
+			}
+
+			const topology = describeDispatchPlan(args).topology;
+			const planScale =
+				tasks.length > 1 ||
+				topology === "compete" ||
+				tasks.some((task) => task.node !== "local" || task.failover === "approved");
+			if (!planScale) return trustRequests(markPrepared(args), parsed.requests);
+			return trustRequests(
+				markReservedPlan(args, {
+					version: 3,
+					topology,
+					source: null,
+					maxWorkers: null,
+					onFailure: null,
+					tasks,
+					costCeilingUsd: resolvedCostCeiling(),
+					deadlineMs: null,
+				}),
+				parsed.requests,
+			);
+		} catch (err) {
+			return preparationFailure(args, err);
+		}
+	};
+	const prepareExecutionArguments = (args: Record<string, unknown>): Record<string, unknown> =>
+		preparedAdmissionArgs.has(args) ? args : prepareAdmissionArguments(args);
+
+	return {
+		name: ToolNames.Dispatch,
+		description:
+			'Dispatch one bounded task with task, or a batch with tasks (never both). Singular example: {agent:"debugger", task:"Verify the receipt boundary", briefing:"Prior receipt evidence...", detach:true}. task is the worker assignment; briefing is separate bounded parent context/data and cannot replace task. Ordinary calls auto-wait; detach:true returns ids for monitoring/steering, and collect is the authoritative terminal batch operation before final synthesis. Batch modes are parallel (default), sequential, pipeline, or compete. Task objects may include persona and tool_profile. Sealed receipts are durable evidence; report receipt integrity, evidence verification, briefing provenance, and project-context provenance separately. Call with list:true to see agents. Do not repeat an identical successful dispatch in the same user turn. Prefer this tool over inline exploration whenever work is read-only fan-out, parallel investigation, or the operator asked for a worker by name; if you cannot dispatch, say so plainly and name the reason, and never narrate or summarize a worker you did not actually dispatch.',
+		parameters: Type.Object({
+			list: Type.Optional(Type.Boolean({ description: "List available agents instead of dispatching." })),
+			from_scout: Type.Optional(
+				Type.Object(
+					{
+						run_id: Type.String({ description: "Exact terminal Scout run id." }),
+						receipt_digest: Type.String({ description: "Exact sha256 receipt digest." }),
+					},
+					{
+						additionalProperties: false,
+						description:
+							"Compile an authenticated split Scout result into one new approval-gated dependency plan; cannot combine with any other argument.",
+					},
+				),
+			),
+			task: Type.Optional(
+				Type.String({
+					description:
+						"Singular worker assignment/instructions. Use tasks instead for a batch; briefing is separate context and cannot replace task.",
+				}),
+			),
+			tasks: Type.Optional(
+				Type.Array(
+					Type.Union([
+						Type.String(),
+						Type.Object({
+							task: Type.String({ description: "Concrete agent task with expected output and constraints." }),
+							briefing: Type.Optional(
+								Type.String({
+									description: `Per-task parent context/data override, max ${DISPATCH_BRIEFING_MAX_BYTES} UTF-8 bytes.`,
+								}),
+							),
+							agent: Type.Optional(Type.String({ description: "Agent recipe id (default coder)." })),
+							persona: Type.Optional(
+								Type.String({
+									description:
+										"Ad-hoc specialist persona to substitute for the recipe body inside the stable worker shell, max 8000 chars.",
+								}),
+							),
+							tool_profile: Type.Optional(stringEnum(TOOL_PROFILE_NAMES, "Narrow this worker's available tools.")),
+							target: Type.Optional(Type.String()),
+							model: Type.Optional(Type.String()),
+							node: Type.Optional(Type.String({ description: "Fleet node pin: local or a fleet.nodes id." })),
+							cwd: Type.Optional(Type.String()),
+						}),
+					]),
+					{ description: "Tasks to dispatch; a single object or string is accepted and wrapped." },
+				),
+			),
+			mode: Type.Optional(
+				stringEnum(
+					["parallel", "sequential", "pipeline", "compete"],
+					"Run tasks concurrently (default), one at a time, as a pipeline where each task receives the previous task's output as input data, or as a compete where N candidates build the same single task in scratch worktrees and a judge picks the winner.",
+				),
+			),
+			detach: Type.Optional(
+				Type.Boolean({
+					description:
+						"Return immediately after admission with a batch id and run ids; runs continue in the background. Collect later with the monitor tool. Parallel mode only.",
+				}),
+			),
+			review: Type.Optional(
+				Type.Union(
+					[
+						Type.Boolean(),
+						Type.Object({
+							reviewer: Type.Optional(
+								Type.String({
+									description: "Reviewer agent recipe id (default: the builder's agent as a read-only reviewer).",
+								}),
+							),
+							max_cycles: Type.Optional(
+								Type.Number({
+									description: "Max review/revise cycles before the gate needs an operator decision (default 2, max 4).",
+								}),
+							),
+							node: Type.Optional(Type.String({ description: "Fleet node pin for the reviewer." })),
+							model: Type.Optional(Type.String({ description: "Model override for the reviewer." })),
+							target: Type.Optional(Type.String({ description: "Target override for the reviewer." })),
+						}),
+					],
+					{
+						description:
+							"Reviewer gate for a single task: the builder runs, a read-only reviewer verdicts pass/revise/fail against the workspace, and revise re-runs the builder with the findings.",
+					},
+				),
+			),
+			candidates: Type.Optional(Type.Number({ description: "Compete candidates 2..4 (mode=compete only, default 2)." })),
+			judge: Type.Optional(
+				Type.Object(
+					{
+						agent: Type.Optional(Type.String({ description: "Judge agent recipe id (default: the builder's agent)." })),
+						model: Type.Optional(Type.String()),
+						target: Type.Optional(Type.String()),
+						node: Type.Optional(Type.String({ description: "Fleet node pin for the judge." })),
+					},
+					{ description: "Read-only judge that ranks compete candidates." },
+				),
+			),
+			apply_winner: Type.Optional(
+				Type.Object(
+					{
+						branch: Type.String({ description: "Preserved winner branch: clio/compete/<group>/<n>." }),
+						cwd: Type.Optional(Type.String({ description: "Repository root (default: current directory)." })),
+					},
+					{
+						description:
+							"Apply a preserved compete winner: merges its branch and cleans up the compete group. Supervised autonomy parks this call so the operator confirms the winner.",
+					},
+				),
+			),
+			agent: Type.Optional(
+				Type.String({
+					description: "Default agent recipe for string tasks, or auto for bounded agent selection (default coder).",
+				}),
+			),
+			briefing: Type.Optional(
+				Type.String({
+					description: `Separate bounded parent context/data for task, or the shared default for tasks; never worker instructions and never a task replacement. Max ${DISPATCH_BRIEFING_MAX_BYTES} UTF-8 bytes.`,
+				}),
+			),
+			persona: Type.Optional(
+				Type.String({
+					description: "Default ad-hoc specialist persona for dispatched tasks, max 8000 chars.",
+				}),
+			),
+			tool_profile: Type.Optional(stringEnum(TOOL_PROFILE_NAMES, "Default worker tool profile.")),
+			target: Type.Optional(Type.String({ description: "Default configured target id (omit for fleet default)." })),
+			model: Type.Optional(Type.String({ description: "Default model override." })),
+			node: Type.Optional(
+				Type.String({ description: "Default fleet node pin: local or a fleet.nodes id (omit for automatic placement)." }),
+			),
+			routing: Type.Optional(
+				Type.Object(
+					{
+						posture: Type.Optional(stringEnum(["manual", "quality", "balanced", "latency", "economy"] as const)),
+						maxCostUsd: Type.Optional(Type.Number({ exclusiveMinimum: 0 })),
+						deadlineMs: Type.Optional(Type.Integer({ exclusiveMinimum: 0 })),
+						minimumQuality: Type.Optional(Type.Number({ minimum: 0, maximum: 1 })),
+						requiredCapabilities: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+						locality: Type.Optional(stringEnum(["local-only", "prefer-local", "any"] as const)),
+						failover: Type.Optional(stringEnum(["none", "approved"] as const)),
+					},
+					{
+						additionalProperties: false,
+						description: "Advisory posture plus hard routing bounds. Exact target/model/node pins remain manual.",
+					},
+				),
+			),
+			thinking_level: Type.Optional(stringEnum(THINKING_LEVELS)),
+			cwd: Type.Optional(Type.String({ description: "Default agent working directory." })),
+			timeout_ms: Type.Optional(Type.Number({ description: "Abort the dispatch after this many ms." })),
+			max_output_bytes: Type.Optional(Type.Number({ description: "Max summary bytes returned." })),
+		}),
+		baseActionClass: "dispatch",
+		executionMode: "sequential",
+		prepareAdmissionArguments,
+		disposeAdmissionArguments: (args) => {
+			const ownerId = trustedReservationOwners.get(args);
+			if (ownerId !== undefined) deps.dispatch.reservations?.rollbackUnconsumed(ownerId);
+		},
+		prepareArguments: prepareExecutionArguments,
+		describeDispatchPlan: (args) => {
+			const trusted = trustedResolvedPlans.get(args);
+			return describeDispatchPlan(trusted === undefined ? args : { ...args, [RESOLVED_DISPATCH_PLAN_ARGUMENT]: trusted });
+		},
+		async run(rawArgs, options): Promise<ToolResult> {
+			const args = prepareExecutionArguments(rawArgs);
+			const preparationError = args[DISPATCH_PLAN_PREPARATION_ERROR_ARGUMENT];
+			if (typeof preparationError === "string") {
+				return {
+					kind: "error",
+					message: preparationError.startsWith("dispatch: ")
+						? preparationError
+						: `dispatch: plan admission failed: ${preparationError}`,
+				};
+			}
+			if (args.list === true) {
+				const catalog = deps.getAgentCatalog?.().trim() ?? "";
+				if (catalog.length === 0) {
+					return { kind: "error", message: "dispatch: no agent catalog is available in this context" };
+				}
+				return { kind: "ok", output: catalog };
+			}
+			try {
+				recoverPendingGateEvidence(deps);
+			} catch (error) {
+				return {
+					kind: "error",
+					message: `dispatch: pending gate evidence recovery failed closed: ${competeErrorMessage(error)}`,
+				};
+			}
+			if (args.apply_winner !== undefined) {
+				const confirmation = resolvedDispatchPlanFromArgs(args)?.confirmation;
+				if (confirmation !== undefined) {
+					const branch = isRecord(args.apply_winner) ? stringArg(args.apply_winner, "branch") : undefined;
+					if (branch !== confirmation.branch) {
+						return { kind: "error", message: "dispatch: winner confirmation differs from the approved plan" };
+					}
+				}
+				const approval = options?.approval;
+				const authority =
+					approval?.actionClass === "dispatch"
+						? {
+								outcome: "operator-confirmed" as const,
+								requestId: approval.requestId,
+								requestedBy: approval.requestedBy,
+							}
+						: deps.getAutonomy?.() === "full-auto"
+							? { outcome: "full-auto-applied" as const }
+							: null;
+				let protectedPaths: string[];
+				try {
+					protectedPaths = deps.dispatch.protectedArtifactState?.().artifacts.map((artifact) => artifact.path) ?? [];
+				} catch (error) {
+					return {
+						kind: "error",
+						message: `dispatch: protected artifact state is unavailable: ${competeErrorMessage(error)}`,
+					};
+				}
+				return runApplyWinner(args, authority, deps.competeWorktrees?.mergeWinner, protectedPaths);
+			}
+			const trustedRequests = trustedParsedRequests.get(args);
+			const parsed =
+				trustedRequests === undefined
+					? parseRequests(args)
+					: ({ ok: true, requests: structuredClone(trustedRequests) } as const);
+			if (!parsed.ok) return { kind: "error", message: parsed.message };
+			const validModes = ["parallel", "sequential", "pipeline", "compete"];
+			if (args.mode !== undefined && !validModes.includes(String(args.mode))) {
+				return {
+					kind: "error",
+					message: `dispatch: mode must be parallel, sequential, pipeline, or compete; got '${String(args.mode)}'`,
+				};
+			}
+			const mode =
+				args.mode === "sequential"
+					? "sequential"
+					: args.mode === "pipeline"
+						? "pipeline"
+						: args.mode === "compete"
+							? "compete"
+							: "parallel";
+			if (options?.signal?.aborted) return { kind: "error", message: "dispatch: aborted" };
+			const maxOutputBytes = maxOutputBytesArg(args);
+			const timeoutMs = timeoutMsArg(args);
+			const reviewParsed = reviewSettingsFromArgs(args);
+			if (!reviewParsed.ok) return { kind: "error", message: reviewParsed.message };
+			let review = reviewParsed.review;
+
+			// Plan-scale calls are either approved at supervised admission or run
+			// unstopped at full-auto; every run seals the same plan hash.
+			const autonomy = deps.getAutonomy?.() ?? "auto-edit";
+			const authenticatedApproval = options?.approval?.actionClass === "dispatch" ? options.approval : undefined;
+			const trustedResolvedPlan = trustedResolvedPlans.get(args) ?? null;
+			const planArgs =
+				trustedResolvedPlan === null ? args : { ...args, [RESOLVED_DISPATCH_PLAN_ARGUMENT]: trustedResolvedPlan };
+			const planView = describeDispatchPlan(planArgs);
+			// Production preparation always registers the authoritative snapshot.
+			// The parser remains available in dispatch-plan.ts for direct utility
+			// tests/tools, but a hidden model-supplied field is never execution trust.
+			const resolvedPlan = trustedResolvedPlan;
+			const reservationOwnerId = trustedReservationOwners.get(args);
+			// Stamp this call's own id on every request before the mode branches
+			// split them. Derived sub-requests that spread a base request inherit
+			// it; the ones built fresh (reviewer, judge) copy it explicitly. A
+			// surface that cannot find the parent still renders the run, just not
+			// nested, so an absent id is never an error.
+			const parentToolCallId = options?.toolCallId;
+			let requests: ReadonlyArray<DispatchRequest> =
+				parentToolCallId === undefined || parentToolCallId.length === 0
+					? parsed.requests
+					: parsed.requests.map((request) => ({ ...request, parentToolCallId }));
+			if (planView.planScale && deps.dispatch.preview !== undefined && resolvedPlan === null) {
+				return { kind: "error", message: "dispatch: resolved plan is missing after admission" };
+			}
+			if (planView.planScale && autonomy !== "full-auto" && authenticatedApproval === undefined) {
+				return {
+					kind: "error",
+					message: "dispatch: resolved plan requires a registry-authenticated operator approval",
+				};
+			}
+			if (resolvedPlan !== null) {
+				const primaryRole = review !== undefined ? "builder" : mode === "compete" ? "candidate" : "task";
+				const primaryTasks = resolvedPlan.tasks.filter((task) => task.role === primaryRole);
+				const executionTasks = primaryRole === "task" ? primaryTasks : primaryTasks.slice(0, 1);
+				if (executionTasks.length !== requests.length) {
+					return {
+						kind: "error",
+						message: `dispatch: resolved plan has ${executionTasks.length} primary task(s), expected ${requests.length}`,
+					};
+				}
+				requests = requests.map((request, index) => {
+					const task = executionTasks[index];
+					const pinned = withResolvedPlanTaskPin(request, task);
+					return reservationOwnerId !== undefined && task?.role !== undefined && task.position !== undefined
+						? {
+								...pinned,
+								reservation: {
+									ownerId: reservationOwnerId,
+									memberId: task.stepId ?? `${task.role}-${task.position}`,
+								},
+							}
+						: pinned;
+				});
+				if (review !== undefined) {
+					const reviewer = resolvedPlan.tasks.find((task) => task.role === "reviewer");
+					if (reviewer === undefined) {
+						return { kind: "error", message: "dispatch: resolved review plan has no reviewer task" };
+					}
+					review = {
+						...review,
+						reviewer: reviewer.agent,
+						target: reviewer.target,
+						model: reviewer.model,
+						node: reviewer.node,
+						resolvedTasks: resolvedPlan.tasks,
+					};
+				}
+			}
+			if (planView.planScale) {
+				const plan: RunPlanProvenance = {
+					hash: planView.hash,
+					topology: planView.topology,
+					taskCount: planView.taskCount,
+					approval: authenticatedApproval !== undefined ? "operator" : "full-auto",
+					source:
+						resolvedPlan?.source === null || resolvedPlan?.source === undefined
+							? null
+							: {
+									kind: "scout-transition",
+									runId: resolvedPlan.source.runId,
+									receiptDigest: resolvedPlan.source.receiptDigest,
+									executionPlanHash: resolvedPlan.source.executionPlanHash,
+								},
+					...(authenticatedApproval !== undefined
+						? {
+								approvalRequestId: authenticatedApproval.requestId,
+								approvalRequestedBy: authenticatedApproval.requestedBy,
+							}
+						: {}),
+					...(planView.costCeilingUsd !== undefined ? { costCeilingUsd: planView.costCeilingUsd } : {}),
+				};
+				requests = requests.map((request) => ({ ...request, plan }));
+			}
+			const backgroundRefusal =
+				resolvedPlan?.topology === "fleet"
+					? "a Scout dependency plan drives its stages from this turn"
+					: mode === "compete"
+						? "compete holds its judge gate in this turn"
+						: review !== undefined
+							? "a review gate holds its cycle state in this turn"
+							: mode === "pipeline" && requests.length > 1
+								? "a pipeline threads each step's output through this turn"
+								: timeoutMs !== undefined
+									? `this call set timeout_ms=${timeoutMs} and nobody would be left to enforce the deadline`
+									: deps.dispatch.detached === undefined
+										? "detached batch records are unavailable in this context"
+										: null;
+			const background = createBackgroundSwitch();
+			// Review and Scout both execute under mode=parallel, so the operator-facing
+			// label names the topology they actually asked for.
+			const backgroundLabel = resolvedPlan?.topology === "fleet" ? "fleet" : review !== undefined ? "review" : mode;
+			const releaseBackground = registerBackgroundControl(deps, options?.toolCallId, {
+				label: `dispatch (${backgroundLabel})`,
+				refusal: backgroundRefusal,
+				fire: () => background.fire(),
+			});
+			try {
+				if (resolvedPlan?.topology === "fleet") {
+					const executionPlan = trustedExecutionPlans.get(args);
+					if (
+						executionPlan === undefined ||
+						resolvedPlan.source === null ||
+						resolvedPlan.deadlineMs === null ||
+						reservationOwnerId === undefined
+					) {
+						return { kind: "error", message: "dispatch: trusted Scout dependency plan is unavailable" };
+					}
+					if (executionPlan.hash !== resolvedPlan.source.executionPlanHash) {
+						return { kind: "error", message: "dispatch: Scout dependency plan hash drifted after admission" };
+					}
+					if (!scoutPlanAuthorityGranted(resolvedPlan, authenticatedApproval !== undefined, autonomy === "full-auto")) {
+						return { kind: "error", message: "dispatch: Scout dependency plan lacks authenticated authority grants" };
+					}
+					const executable = compileExecutionPlan({
+						topology: executionPlan.topology,
+						rootTask: executionPlan.rootTask,
+						maxWorkers: executionPlan.maxWorkers,
+						onFailure: executionPlan.onFailure,
+						steps: requireAgentSteps(executionPlan.steps).map((step) => ({
+							...step,
+							approvedAuthority: step.requestedAuthority,
+						})),
+					});
+					try {
+						const outcome = await runScoutContinuationPlan({
+							dispatch: deps.dispatch,
+							plan: executable,
+							artifact: resolvedPlan,
+							requests,
+							reservationOwnerId,
+							...(options?.signal === undefined ? {} : { signal: options.signal }),
+							register: (handle, agentId) =>
+								deps.runEvents.registerSingle(handle, agentId, fallbackProgressBus(deps)).completion,
+							complete: (receipt, summary) => {
+								const completed = completeRun(deps, receipt, summary);
+								return { value: completed, integrityValid: completed.integrity.ok };
+							},
+						});
+						const output = formatDispatchOutput("fleet", outcome.runs, maxOutputBytes);
+						const details = {
+							...dispatchDetails(deps, "fleet", outcome.runs),
+							executionPlanHash: executable.hash,
+							skippedSteps: outcome.skipped,
+						};
+						const failed = outcome.runs.some((run) => run.receipt.exitCode !== 0) || outcome.skipped.length > 0;
+						return failed ? { kind: "error", message: output, details } : { kind: "ok", output, details };
+					} catch (error) {
+						return {
+							kind: "error",
+							message: `dispatch: Scout dependency plan failed: ${error instanceof Error ? error.message : String(error)}`,
+						};
+					}
+				}
+
+				if (args.detach === true) {
+					if (mode !== "parallel") {
+						return { kind: "error", message: `dispatch: detach only supports parallel mode; got '${mode}'` };
+					}
+					if (review !== undefined) {
+						return {
+							kind: "error",
+							message: "dispatch: detach cannot combine with a review gate; run gated dispatch attached",
+						};
+					}
+					if (timeoutMs !== undefined) {
+						return {
+							kind: "error",
+							message:
+								'dispatch: detach cannot enforce timeout_ms because no caller waits on the runs; monitor(mode="wait") only observes for a bounded time, and steer(action="cancel") stops a run',
+						};
+					}
+					try {
+						return await runDetached(deps, requests, options?.sessionId ?? null);
+					} catch (err) {
+						return { kind: "error", message: dispatchErrorMessage(err) };
+					}
+				}
+
+				if (mode === "compete") {
+					if (requests.length !== 1 || requests[0] === undefined) {
+						return { kind: "error", message: COMPETE_SINGLE_TASK_MESSAGE };
+					}
+					if (review !== undefined) {
+						return { kind: "error", message: COMPETE_NO_REVIEW_MESSAGE };
+					}
+					const competeParsed = competeSettingsFromArgs(args);
+					if (!competeParsed.ok) return { kind: "error", message: competeParsed.message };
+					let compete = competeParsed.compete;
+					if (resolvedPlan !== null) {
+						const judge = resolvedPlan.tasks.find((task) => task.role === "judge");
+						if (judge === undefined) {
+							return { kind: "error", message: "dispatch: resolved compete plan has no judge task" };
+						}
+						compete = {
+							...compete,
+							judge: { agent: judge.agent, target: judge.target, model: judge.model, node: judge.node },
+							resolvedTasks: resolvedPlan.tasks,
+						};
+					}
+					try {
+						const outcome = await runCompete(deps, requests[0], compete, autonomy, timeoutMs, options?.signal);
+						return competeResult(deps, outcome, autonomy, maxOutputBytes);
+					} catch (err) {
+						return { kind: "error", message: dispatchErrorMessage(err) };
+					}
+				}
+
+				if (review !== undefined) {
+					if (requests.length !== 1 || requests[0] === undefined) {
+						return { kind: "error", message: REVIEW_SINGLE_TASK_MESSAGE };
+					}
+					if (mode !== "parallel") {
+						return { kind: "error", message: `dispatch: review does not combine with mode=${mode}` };
+					}
+					try {
+						const outcome = await runReviewGated(deps, requests[0], review, timeoutMs, options?.signal);
+						return reviewGateResult(deps, outcome, maxOutputBytes);
+					} catch (err) {
+						return { kind: "error", message: dispatchErrorMessage(err) };
+					}
+				}
+
+				try {
+					let runs: CompletedRun[];
+					// Only the concurrent fan-out has peers, so only it has a board.
+					let board: string | null = null;
+					if (mode === "pipeline" && requests.length > 1) {
+						runs = await runPipeline(deps, requests, timeoutMs, options?.signal);
+					} else if (mode === "sequential" || mode === "pipeline" || requests.length === 1) {
+						// A single-task pipeline has nothing to thread, so it degrades to
+						// plain sequential and no pipeline-input message is sent.
+						runs = await runSequential(deps, requests, mode, timeoutMs, options?.signal, background);
+					} else {
+						const batch = await runBatch(deps, requests, timeoutMs, options?.signal, background);
+						runs = batch.runs;
+						board = batch.board;
+					}
+					const output = formatDispatchOutput(mode, runs, maxOutputBytes, board);
+					const details = dispatchDetails(deps, mode, runs, board);
+					const failed = runs.filter((run) => run.receipt.exitCode !== 0);
+					if (failed.length > 0) return { kind: "error", message: output, details };
+					return { kind: "ok", output, details };
+				} catch (err) {
+					if (err instanceof DispatchBackgroundedError) {
+						return await backgroundedDispatchResult(deps, err, mode, options?.sessionId ?? null);
+					}
+					if (err instanceof PipelineHaltError) {
+						const haltMessage = `dispatch: ${err.message}`;
+						const output = formatDispatchOutput("pipeline", err.runs, maxOutputBytes);
+						return {
+							kind: "error",
+							message: `${haltMessage}\n\n${output}`,
+							details: dispatchDetails(deps, "pipeline", err.runs),
+						};
+					}
+					return { kind: "error", message: dispatchErrorMessage(err) };
+				}
+			} finally {
+				releaseBackground();
+			}
+		},
+	};
+}
+
+/**
+ * One at a time: each run completes before the next dispatches. Also serves
+ * single-task parallel calls, where batching adds nothing. The timeout and
+ * abort signal cover the whole sequence; remaining tasks are skipped once
+ * either fires and the skip is reported through the thrown error.
+ */
+async function runSequential(
+	deps: RegisteredDispatchToolDeps,
+	requests: ReadonlyArray<DispatchRequest>,
+	mode: string,
+	timeoutMs: number | undefined,
+	signal: AbortSignal | undefined,
+	background: BackgroundSwitch,
+): Promise<CompletedRun[]> {
+	const runs: CompletedRun[] = [];
+	let expired = false;
+	let activeRunId: string | null = null;
+	// The operator signal is a cancel; the timer is a timeout. Both stop the
+	// sequence, but the timeout carries a cause so the receipt names it.
+	const abortActive = (bySignal: boolean): void => {
+		expired = true;
+		if (activeRunId !== null) {
+			deps.dispatch.abort(
+				activeRunId,
+				bySignal ? undefined : { cause: "timeout", detail: `timed out after ${timeoutMs}ms` },
+			);
+		}
+	};
+	const onSignalAbort = (): void => abortActive(true);
+	const timer = timeoutMs !== undefined ? setTimeout(() => abortActive(false), timeoutMs) : null;
+	signal?.addEventListener("abort", onSignalAbort, { once: true });
+	try {
+		for (const [index, request] of requests.entries()) {
+			if (expired || signal?.aborted) {
+				throw new Error(
+					`${mode} dispatch stopped after ${runs.length}/${requests.length} task(s): ${signal?.aborted ? "aborted" : `timed out after ${timeoutMs}ms`}`,
+				);
+			}
+			const handle = await deps.dispatch.dispatch(request);
+			activeRunId = handle.runId;
+			const registered = deps.runEvents.registerSingle(handle, request.agentId, fallbackProgressBus(deps));
+			const completion = registered.completion.then((value) => ({ kind: "completed" as const, value }));
+			const settled = await Promise.race([completion, background.requested.then(() => ({ kind: "background" as const }))]);
+			if (settled.kind === "background") {
+				// activeRunId stays set on purpose: the finally below only clears the
+				// timer and the abort listener, and the live step must survive both.
+				completion.catch(() => {});
+				throw new DispatchBackgroundedError(
+					newGateGroupId("batch"),
+					[{ runId: handle.runId, assignmentId: handle.runId, agentId: request.agentId }],
+					[...runs],
+					requests.slice(index + 1).map((later) => later.agentId),
+				);
+			}
+			activeRunId = null;
+			runs.push(completeRun(deps, settled.value.receipt, settled.value.summary));
+		}
+		return runs;
+	} finally {
+		if (timer) clearTimeout(timer);
+		signal?.removeEventListener("abort", onSignalAbort);
+	}
+}
+
+/** A pipeline step failed when its worker exited nonzero or its outcome is not success. */
+function isPipelineStepFailure(receipt: RunReceipt): boolean {
+	if (receipt.exitCode !== 0) return true;
+	return receipt.outcome !== undefined && receipt.outcome !== "succeeded";
+}
+
+function pipelineFailureReason(receipt: RunReceipt): string {
+	if (receipt.outcome !== undefined && receipt.outcome !== "succeeded") return `outcome=${receipt.outcome}`;
+	return `exit=${receipt.exitCode}`;
+}
+
+/**
+ * Chain worker outputs: each step runs to completion, then its final assistant
+ * text is threaded to the next step as `pipelineInput` (data, not instruction
+ * text). Step 1 receives none. A failed step halts the chain and the thrown
+ * error names the step and how many later steps were skipped, mirroring
+ * runSequential's "stopped after N/M" phrasing. Whole-sequence timeout and
+ * abort handling match runSequential.
+ */
+async function runPipeline(
+	deps: RegisteredDispatchToolDeps,
+	requests: ReadonlyArray<DispatchRequest>,
+	timeoutMs: number | undefined,
+	signal: AbortSignal | undefined,
+): Promise<CompletedRun[]> {
+	const runs: CompletedRun[] = [];
+	let expired = false;
+	let activeRunId: string | null = null;
+	// The operator signal is a cancel; the timer is a timeout. Both stop the
+	// chain, but the timeout carries a cause so the receipt names it.
+	const abortActive = (bySignal: boolean): void => {
+		expired = true;
+		if (activeRunId !== null) {
+			deps.dispatch.abort(
+				activeRunId,
+				bySignal ? undefined : { cause: "timeout", detail: `timed out after ${timeoutMs}ms` },
+			);
+		}
+	};
+	const onSignalAbort = (): void => abortActive(true);
+	const timer = timeoutMs !== undefined ? setTimeout(() => abortActive(false), timeoutMs) : null;
+	signal?.addEventListener("abort", onSignalAbort, { once: true });
+	try {
+		let previous: { runId: string; text: string } | null = null;
+		for (const [index, base] of requests.entries()) {
+			if (expired || signal?.aborted) {
+				throw new Error(
+					`pipeline dispatch stopped after ${runs.length}/${requests.length} task(s): ${signal?.aborted ? "aborted" : `timed out after ${timeoutMs}ms`}`,
+				);
+			}
+			// Thread the previous step's output as data; the task string the
+			// orchestrator authored is sent verbatim. Step 1 (previous === null)
+			// carries no pipeline input.
+			const request: DispatchRequest =
+				previous === null
+					? base
+					: { ...base, pipelineInput: { fromRunId: previous.runId, position: index + 1, text: previous.text } };
+			const handle = await deps.dispatch.dispatch(request);
+			activeRunId = handle.runId;
+			const registered = deps.runEvents.registerSingle(handle, request.agentId, fallbackProgressBus(deps));
+			const { receipt, summary } = await registered.completion;
+			activeRunId = null;
+			runs.push(completeRun(deps, receipt, summary));
+			if (isPipelineStepFailure(receipt)) {
+				const skipped = requests.length - (index + 1);
+				throw new PipelineHaltError(
+					`pipeline dispatch halted at step ${index + 1}/${requests.length} (run ${receipt.runId}, ${pipelineFailureReason(receipt)}); skipped ${skipped} later step(s)`,
+					[...runs],
+				);
+			}
+			previous = {
+				runId: receipt.runId,
+				text: receipt.output?.state === "final" ? receipt.output.text : "",
+			};
+		}
+		return runs;
+	} finally {
+		if (timer) clearTimeout(timer);
+		signal?.removeEventListener("abort", onSignalAbort);
+	}
+}
+
+interface BatchOutcome {
+	runs: CompletedRun[];
+	/** Rendered board of the batch's shared ledger, null when nothing was posted. */
+	board: string | null;
+}
+
+async function runBatch(
+	deps: RegisteredDispatchToolDeps,
+	requests: ReadonlyArray<DispatchRequest>,
+	timeoutMs: number | undefined,
+	signal: AbortSignal | undefined,
+	background: BackgroundSwitch,
+): Promise<BatchOutcome> {
+	// This arm is the concurrent parallel fan-out, so its peers can see each
+	// other. The ledger opens before admission and every request carries it, so
+	// no worker spawns into a dispatch whose board it cannot reach.
+	const ledgerId = newGateGroupId("ledger");
+	await openAgentLedger(ledgerId);
+	const ledgered = requests.map((request) => ({ ...request, ledger: { id: ledgerId, sequence: 0 } }));
+	const handle = await deps.dispatch.dispatchBatch(ledgered);
+	const registered = deps.runEvents.registerBatch(
+		handle,
+		ledgered.map((request) => request.agentId),
+		fallbackProgressBus(deps),
+	);
+	// The operator signal is a cancel; the timer is a timeout. The timeout
+	// carries a cause so each killed run's receipt names it.
+	const abort = (bySignal: boolean): void => {
+		const reason = bySignal ? undefined : ({ cause: "timeout", detail: `timed out after ${timeoutMs}ms` } as const);
+		for (const runId of handle.assignmentIds) deps.dispatch.abort(runId, reason);
+	};
+	const onSignalAbort = (): void => abort(true);
+	const timer = timeoutMs !== undefined ? setTimeout(() => abort(false), timeoutMs) : null;
+	signal?.addEventListener("abort", onSignalAbort, { once: true });
+	// The board closes when the batch settles in this call. A backgrounded
+	// batch settles elsewhere: its runs are still live and still posting, so
+	// the ledger rides on the converted record and closes at collect instead.
+	let backgrounded = false;
+	try {
+		const completion = registered.completion.then((value) => ({ kind: "completed" as const, value }));
+		const settled = await Promise.race([completion, background.requested.then(() => ({ kind: "background" as const }))]);
+		if (settled.kind === "background") {
+			// The batch drain keeps metering; only this await unwinds. Every run in
+			// a parallel batch is already live, so the whole batch converts.
+			completion.catch(() => {});
+			backgrounded = true;
+			throw new DispatchBackgroundedError(
+				handle.batchId,
+				handle.assignmentIds.map((runId, index) => ({
+					runId,
+					assignmentId: runId,
+					agentId: ledgered[index]?.agentId ?? "unknown",
+				})),
+				[],
+				[],
+				ledgerId,
+			);
+		}
+		const { summaries, receipts } = settled.value;
+		// Every worker has settled and the board has not closed yet, so this is
+		// the whole board the peers built, read once for the model that started
+		// them.
+		const board = renderAgentLedgerBoard(ledgerId);
+		return {
+			runs: receipts.map((receipt) =>
+				completeRun(
+					deps,
+					receipt,
+					summaries.get(receipt.runId) ?? {
+						count: 0,
+						types: [],
+						lastAssistantText: "",
+						terminalAttemptRunId: receipt.runId,
+					},
+				),
+			),
+			board,
+		};
+	} finally {
+		if (timer) clearTimeout(timer);
+		signal?.removeEventListener("abort", onSignalAbort);
+		if (!backgrounded) await closeAgentLedger(ledgerId);
+	}
+}