@iowarp/clio-coder 0.3.1 → 0.3.3

package/dist/dispatch-runner-QPRDDBDX.js

@@ -0,0 +1,1997 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  SPOT_CHECK_GUIDANCE,
+  receiptEvidenceLabels,
+  workerTextLabel,
+  workerTextNonEvidenceNotices
+} from "./chunk-6N5PTWMY.js";
+import {
+  createDispatchRunEventRegistry
+} from "./chunk-6SGHMWE3.js";
+import "./chunk-XBXAASKX.js";
+import {
+  UNVERIFIABLE_RECEIPT_VERIFICATION,
+  candidateDiffStat,
+  claimCompeteGroup,
+  cleanupCompeteGroup,
+  closeAgentLedger,
+  commitCandidateWork,
+  compileExecutionPlan,
+  createCandidateWorktree,
+  decideReviewGate,
+  durableAssistantTextFromEvent,
+  executePlan,
+  extractRunProvenance,
+  finalizePendingGateDecision,
+  isGitRepository,
+  loadCompeteGroup,
+  markCompeteGroupCleanupReady,
+  markCompeteGroupWinnerPreserved,
+  materializePendingGateDecision,
+  mergeWinnerBranch,
+  openAgentLedger,
+  parseCompeteGateResult,
+  preflightPendingGateDecisionMaterialization,
+  preparePendingGateDecisionRecovery,
+  protectedPathsChangedByCompeteBranch,
+  provenanceCompactSuffix,
+  readGateDecisionArtifacts,
+  recoverCleanupReadyCompeteGroups,
+  registerCompeteGroupRun,
+  removeCandidateWorktree,
+  renderAgentLedgerBoard,
+  requireAgentSteps,
+  resolvePendingGateDecision,
+  settleCompeteGroupRun,
+  settleRecoveredCompeteDecision,
+  stagePendingGateDecision,
+  stagePendingGateOutput
+} from "./chunk-SRDMMSEP.js";
+import "./chunk-4BJ5BYCE.js";
+import "./chunk-QKMUKYO7.js";
+import {
+  verifyReceiptIntegrity
+} from "./chunk-AGYYIBLL.js";
+import "./chunk-OOJYHWRB.js";
+import "./chunk-TXOTCRLG.js";
+import "./chunk-G4BMMOKF.js";
+import {
+  RESOLVED_DISPATCH_PLAN_ARGUMENT,
+  describeDispatchPlan,
+  withResolvedPlanTaskPin
+} from "./chunk-DUYJ5IO6.js";
+import {
+  COMPETE_STANCES,
+  JUDGE_GATE_PROMPT,
+  REVIEWER_GATE_PROMPT
+} from "./chunk-LWLEKMDQ.js";
+import {
+  parseScoutResult,
+  resultContractSourceId
+} from "./chunk-STBPMHSX.js";
+import {
+  explainRouteDecision,
+  gateDeciderAgentId,
+  gateRouteCorrelation
+} from "./chunk-GGXXDWE4.js";
+import "./chunk-5UUP6MWO.js";
+import "./chunk-CMZWFGD2.js";
+import "./chunk-I4HZDVNP.js";
+import "./chunk-7MNJORFF.js";
+import "./chunk-OQE5J4C6.js";
+import "./chunk-ECH6PKUQ.js";
+import "./chunk-T6YILFSB.js";
+import "./chunk-VAKQQHWR.js";
+import {
+  truncateUtf8
+} from "./chunk-6XLNIQDB.js";
+import "./chunk-5B2AEOW5.js";
+import "./chunk-CGKSTWHD.js";
+import "./chunk-YHZX5GEU.js";
+import "./chunk-EKMEHE4H.js";
+import "./chunk-LZSJBIVT.js";
+import "./chunk-A3CYT5EX.js";
+import "./chunk-ZDOOVTXZ.js";
+import "./chunk-4VP4KH3K.js";
+import "./chunk-M6SHUN7Q.js";
+import "./chunk-R346GLFC.js";
+import "./chunk-COU2UHX6.js";
+import "./chunk-FQ4SKYE4.js";
+import "./chunk-IKCO5N3L.js";
+import "./chunk-3I7MS7N2.js";
+import "./chunk-IHXBNWMM.js";
+import "./chunk-SST6Z5JA.js";
+import "./chunk-4ZG3XFUR.js";
+import "./chunk-APJ265NV.js";
+import "./chunk-FCSXB6T2.js";
+import "./chunk-YXLYO42X.js";
+import {
+  clioStateDir
+} from "./chunk-BNAZZHFG.js";
+import "./chunk-6EJMN2Y3.js";
+import "./chunk-WEPFGWHJ.js";
+import {
+  BusChannels
+} from "./chunk-OQ33BKR3.js";
+import "./chunk-7CR24IG7.js";
+import "./chunk-IWHMRKLL.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/dispatch-runner.ts
+init_esm_shims();
+import { randomBytes } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// src/tools/dispatch-scout.ts
+init_esm_shims();
+function validateScoutSource(receipt, envelope, agentSpecs) {
+  const integrity = verifyReceiptIntegrity(receipt, envelope);
+  if (!integrity.ok) throw new Error(`dispatch: Scout source receipt failed integrity: ${integrity.reason}`);
+  if (receipt.exitCode !== 0 || receipt.outcome !== void 0 && receipt.outcome !== "succeeded") {
+    throw new Error("dispatch: Scout source did not succeed");
+  }
+  const spec = agentSpecs.find((candidate) => candidate.id === receipt.agentId);
+  if (spec === void 0 || spec.resultContract.kind !== "scout-report") {
+    throw new Error("dispatch: Scout source agent no longer declares scout-report");
+  }
+  const fact = receipt.quality.resultContract;
+  if (fact === null || fact.conformance !== "pass" || fact.sourceId !== resultContractSourceId(spec.resultContract)) {
+    throw new Error("dispatch: Scout source lacks an exact passing result-contract fact");
+  }
+  if (receipt.output?.state !== "final") throw new Error("dispatch: Scout source has no sealed final output");
+  const scout = parseScoutResult(receipt.output.text);
+  if (scout === null) throw new Error("dispatch: Scout source output does not match the current strict contract");
+  return { envelope, receipt, scout, spec };
+}
+function scoutTransitionDetail(input) {
+  try {
+    const source = validateScoutSource(input.receipt, input.envelope, input.agentSpecs);
+    return source.scout.needsSplit ? {
+      kind: "proposed",
+      sourceRunId: source.receipt.runId,
+      sourceReceiptDigest: source.receipt.integrity.digest,
+      subtaskCount: source.scout.proposedSubtasks.length,
+      continueWith: {
+        from_scout: { run_id: source.receipt.runId, receipt_digest: source.receipt.integrity.digest }
+      }
+    } : {
+      kind: "settled",
+      sourceRunId: source.receipt.runId,
+      sourceReceiptDigest: source.receipt.integrity.digest,
+      findings: source.scout.findings.map((finding) => ({ ...finding }))
+    };
+  } catch {
+    return null;
+  }
+}
+function scoutPlanAuthorityGranted(artifact, operatorApproved, fullAuto) {
+  return artifact.tasks.every(
+    (task) => task.authorityGrant !== null && (task.authorityGrant.basis === "operator-plan-approval" && operatorApproved || task.authorityGrant.basis === "full-auto-policy" && fullAuto)
+  );
+}
+async function runScoutContinuationPlan(input) {
+  if (input.artifact.deadlineMs === null) throw new Error("Scout dependency plan has no whole-plan deadline");
+  const assignmentDeadlineAt = Date.now() + input.artifact.deadlineMs;
+  const completedByStep = /* @__PURE__ */ new Map();
+  const byStep = new Map(
+    input.artifact.tasks.map((task, index) => [task.stepId, { task, request: input.requests[index] }])
+  );
+  const result = await executePlan(
+    input.plan,
+    {
+      preflight(step) {
+        const bound = byStep.get(step.id);
+        if (bound?.request === void 0) throw new Error(`Scout step '${step.id}' has no trusted request`);
+        const resolution = input.dispatch.preview?.(bound.request);
+        if (resolution === void 0) throw new Error(`Scout step '${step.id}' cannot be preflighted`);
+        const approved = bound.task.agentDecision?.selected;
+        if (approved === void 0 || resolution.agentId !== approved.agentId || resolution.specFingerprint !== approved.specFingerprint || resolution.targetId !== approved.targetId || resolution.wireModelId !== approved.modelId || resolution.runtimeId !== approved.runtimeId || resolution.node.id !== approved.nodeId || resolution.node.kind !== bound.task.nodeKind || resolution.node.host !== bound.task.nodeHost || resolution.thinkingLevel !== (approved.thinkingLevel ?? null) || resolution.toolSignature !== approved.toolSignature || resolution.endpointIdentityHash !== approved.endpointIdentityHash || resolution.settingsFingerprint !== approved.settingsFingerprint) {
+          throw new Error(`Scout step '${step.id}' drifted from its approved route`);
+        }
+        return { step, costUpperBoundUsd: resolution.costUpperBoundUsd, nodeId: resolution.node.id };
+      },
+      reserve(_plan, admissions) {
+        const cost = admissions.reduce((sum, admission) => sum + admission.costUpperBoundUsd, 0);
+        if (!Number.isFinite(cost) || cost > input.artifact.costCeilingUsd) {
+          throw new Error("Scout dependency plan drifted above its approved cost ceiling");
+        }
+        return { ownerId: input.reservationOwnerId };
+      },
+      async run(step, handoffs, reservation, ledger) {
+        const bound = byStep.get(step.id);
+        if (bound?.request === void 0) throw new Error(`Scout step '${step.id}' has no trusted request`);
+        const request = {
+          ...bound.request,
+          predecessorHandoffs: handoffs,
+          reservation,
+          assignmentDeadlineAt,
+          ...ledger !== void 0 ? { ledger } : {}
+        };
+        const handle = await input.dispatch.dispatch(request);
+        return {
+          assignmentId: handle.runId,
+          result: input.register(handle, request.agentId).then(({ receipt, summary }) => {
+            const completed = input.complete(receipt, summary);
+            completedByStep.set(step.id, completed.value);
+            return {
+              stepId: step.id,
+              assignmentId: handle.runId,
+              terminalRunId: receipt.runId,
+              receiptDigest: receipt.integrity.digest,
+              output: receipt.output?.state === "final" ? receipt.output.text : "",
+              succeeded: receipt.exitCode === 0 && (receipt.outcome === void 0 || receipt.outcome === "succeeded"),
+              integrityValid: completed.integrityValid
+            };
+          })
+        };
+      },
+      cancel: (assignmentId) => input.dispatch.abort(assignmentId),
+      release: (ownerId) => input.dispatch.reservations?.rollbackUnconsumed(ownerId),
+      releaseUnconsumed: (ownerId) => input.dispatch.reservations?.rollbackUnconsumed(ownerId)
+    },
+    input.signal
+  );
+  return {
+    runs: input.plan.steps.flatMap((step) => {
+      const completed = completedByStep.get(step.id);
+      return completed === void 0 ? [] : [completed];
+    }),
+    skipped: result.skipped
+  };
+}
+
+// src/tools/dispatch-runner.ts
+var TRUNCATION_MARKER = "\n[agent output truncated]";
+function createBackgroundSwitch() {
+  let fired = false;
+  let signal = () => {
+  };
+  const requested = new Promise((resolve) => {
+    signal = resolve;
+  });
+  return {
+    requested,
+    fire: () => {
+      if (fired) return;
+      fired = true;
+      signal();
+    }
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function rawAssistantTextFromEvent(event) {
+  return durableAssistantTextFromEvent(event);
+}
+function normalizedAssistantText(summary) {
+  return summary.lastAssistantText.trim();
+}
+function fallbackProgressBus(deps) {
+  return deps.dispatch.ownsProgressBus?.(deps.bus) === true ? void 0 : deps.bus;
+}
+async function consumeGateSensitiveDispatchEvents(deps, runId, agentId, events) {
+  const summary = { 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;
+}
+async function runDetached(deps, requests, sessionId) {
+  const detached = deps.dispatch.detached;
+  if (!detached) {
+    return { kind: "error", message: "dispatch: detach is not supported in this context" };
+  }
+  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(() => {
+  });
+  await deps.dispatch.assignments?.flushWrites?.();
+  try {
+    await detached.register({
+      batchId: handle.batchId,
+      runs,
+      sessionId,
+      ...ledgerId !== null ? { ledgerId } : {}
+    });
+  } catch (err) {
+    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 }))
+    }
+  };
+}
+function registerBackgroundControl(deps, toolCallId, plan) {
+  const registry = deps.background;
+  if (registry === void 0 || toolCallId === void 0 || toolCallId.length === 0) return () => {
+  };
+  let release = () => {
+  };
+  release = registry.register({
+    toolCallId,
+    label: plan.label,
+    convert: () => {
+      if (plan.refusal !== null) {
+        return { ok: false, message: `${plan.label} cannot be backgrounded: ${plan.refusal}` };
+      }
+      release();
+      plan.fire();
+      return { ok: true, message: `${plan.label} is moving to the background as a detached batch` };
+    }
+  });
+  return () => release();
+}
+var DispatchBackgroundedError = class extends Error {
+  constructor(batchId, live, settled, undispatched, ledgerId = null) {
+    super("dispatch: backgrounded by operator");
+    this.batchId = batchId;
+    this.live = live;
+    this.settled = settled;
+    this.undispatched = undispatched;
+    this.ledgerId = ledgerId;
+    this.name = "DispatchBackgroundedError";
+  }
+  batchId;
+  live;
+  settled;
+  undispatched;
+  ledgerId;
+};
+async function backgroundedDispatchResult(deps, converted, mode, sessionId) {
+  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 }
+    };
+  }
+  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]
+    }
+  };
+}
+function successNote(receipt) {
+  if (receipt.outcome !== void 0 && receipt.outcome !== "succeeded") return null;
+  if (receipt.exitCode !== 0) return null;
+  return receipt.outcomeDetail ?? null;
+}
+function completeRun(deps, receipt, summary, pendingGate) {
+  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 !== void 0 ? { pendingGate } : {}
+  };
+}
+var PipelineHaltError = class extends Error {
+  constructor(message, runs) {
+    super(message);
+    this.runs = runs;
+    this.name = "PipelineHaltError";
+  }
+  runs;
+};
+function integrityFailureBanner(run) {
+  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.`;
+}
+function withAgentLedgerBoard(body, board) {
+  return board === null ? body : `${body}
+
+${board}`;
+}
+function formatDispatchOutput(mode, runs, maxOutputBytes, board = null) {
+  const failed = runs.filter((run) => run.receipt.exitCode !== 0);
+  const perRunOutputBytes = Math.max(1024, Math.floor(maxOutputBytes / Math.max(1, runs.length)));
+  const integrityBanners = runs.map((run) => integrityFailureBanner(run)).filter((banner) => 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}` : "";
+      const outcomeSuffix = receipt.outcome !== void 0 && receipt.outcome !== "succeeded" ? ` outcome=${receipt.outcome}${receipt.outcomeDetail ? ` detail=${receipt.outcomeDetail}` : ""}` : "";
+      const failure = receipt.failureMessage ? ` failure=${receipt.failureMessage}` : "";
+      const stepLabel = mode === "pipeline" ? `step ${index + 1}/${runs.length} ` : "";
+      const provenance = provenanceCompactSuffix(extractRunProvenance(receipt));
+      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 !== void 0 && receipt.routingIntent !== void 0 ? ` route_decision=${receipt.routeDecision.decisionHash} route_mode=${receipt.routeDecision.mode}` : "";
+      const answerText = run.integrity.ok && (receipt.output?.state === "final" || receipt.outcome !== void 0 && 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, mode, runs, board = null) {
+  const failed = runs.filter((run) => run.receipt.exitCode !== 0);
+  let transition = 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 }) => {
+      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 !== void 0 && receipt.outcome !== "succeeded" ? { outcome: receipt.outcome, outcomeDetail: receipt.outcomeDetail ?? null } : {},
+        ...provenance.pipeline !== void 0 ? { pipeline: provenance.pipeline } : {},
+        ...provenance.personaOverride !== void 0 ? { personaOverride: provenance.personaOverride } : {},
+        ...provenance.escalation !== void 0 ? { escalation: provenance.escalation } : {},
+        ...provenance.autonomyEnforcement !== void 0 ? { autonomyEnforcement: provenance.autonomyEnforcement } : {},
+        ...integrity.ok && receipt.routeDecision !== void 0 && receipt.routingIntent !== void 0 ? { routing: explainRouteDecision(receipt.routeDecision, receipt.routingIntent) } : {}
+      };
+    })
+  };
+}
+function newGateGroupId(prefix) {
+  return `${prefix}-${Date.now().toString(36)}-${randomBytes(3).toString("hex")}`;
+}
+function subjectRef(receipt) {
+  return { runId: receipt.runId, digest: receipt.integrity?.digest ?? null };
+}
+function gateCorrelationOf(subject, decider) {
+  const facts = (receipt) => ({
+    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 };
+}
+function competeCorrelation(candidates, decider) {
+  const subject = candidates[0]?.receipt;
+  if (subject === void 0) throw new Error("compete decision requires at least one candidate receipt");
+  return gateCorrelationOf(subject, decider);
+}
+function reviewerTask(originalTask, builderRunId, cycle) {
+  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");
+}
+var 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";
+var COMPETE_SINGLE_TASK_MESSAGE = "dispatch: compete requires exactly one task";
+var COMPETE_NO_REVIEW_MESSAGE = "dispatch: compete has its own judge and cannot combine with review";
+async function runReviewGated(deps, base, review, timeoutMs, signal) {
+  const group = newGateGroupId("review");
+  const runs = [];
+  const decisions = [];
+  const recordDecision = (draft, pending) => {
+    const decision = pending ? finalizePendingGateDecision(pending, draft) : materializePendingGateDecision(stagePendingGateDecision(draft));
+    decisions.push(decision);
+    return decision;
+  };
+  let expired = false;
+  let activeRunId = null;
+  const abortActive = (bySignal) => {
+    expired = true;
+    if (activeRunId !== null) {
+      deps.dispatch.abort(
+        activeRunId,
+        bySignal ? void 0 : { cause: "timeout", detail: `timed out after ${timeoutMs}ms` }
+      );
+    }
+  };
+  const onSignalAbort = () => abortActive(true);
+  const timer = timeoutMs !== void 0 ? setTimeout(() => abortActive(false), timeoutMs) : null;
+  signal?.addEventListener("abort", onSignalAbort, { once: true });
+  const runOne = async (request) => {
+    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;
+    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 {
+        }
+        await Promise.allSettled([handle.finalPromise]);
+        activeRunId = null;
+        throw error;
+      }
+    }
+    let receipt;
+    try {
+      receipt = await handle.finalPromise;
+    } finally {
+      activeRunId = null;
+    }
+    const completed = completeRun(deps, receipt, summary, pendingGate);
+    runs.push(completed);
+    return completed;
+  };
+  try {
+    let findings = null;
+    for (let cycle = 1; cycle <= review.maxCycles; cycle += 1) {
+      const builderGate = {
+        role: "builder",
+        group,
+        cycle,
+        ...findings !== null ? { subjects: [subjectRef(findings.reviewer.receipt)], verdict: "revise" } : {}
+      };
+      const builderRequest = {
+        ...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 = {
+        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 !== void 0 ? { cwd: base.cwd } : {},
+        ...review.node !== void 0 ? { node: review.node } : {},
+        ...review.model !== void 0 ? { model: review.model } : {},
+        ...review.target !== void 0 ? { target: review.target } : {},
+        ...base.plan !== void 0 ? { plan: base.plan } : {},
+        ...base.parentToolCallId !== void 0 ? { parentToolCallId: base.parentToolCallId } : {},
+        ...base.reservation !== void 0 ? { 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, candidates, stats) {
+  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, runId) {
+  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;
+  try {
+    receipt = JSON.parse(readFileSync(path, "utf8"));
+  } 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 === void 0) throw new Error(`pending gate receipt ${runId} has no integrity digest`);
+  return receipt;
+}
+function recoveredCorrelation(deps, subjects, decider) {
+  const first = subjects[0];
+  const subject = first === void 0 ? 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, draft) {
+  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);
+}
+function recoverPendingGateEvidence(deps) {
+  const recovery = preparePendingGateDecisionRecovery();
+  const resolved = [];
+  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;
+    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 ? void 0 : record.subjects[pick - 1];
+    const candidateReceipt = pickedSubject === void 0 ? null : readVerifiedGateReceipt(deps, pickedSubject.runId);
+    if (pickedSubject !== void 0 && candidateReceipt === null) {
+      throw new Error(
+        `pending compete decision ${record.id} has no verified candidate receipt for ${pickedSubject.runId}`
+      );
+    }
+    let blockedProtected = [];
+    if (pick !== null && pickedSubject !== void 0 && 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 !== void 0 && candidateReceipt !== null && !isPipelineStepFailure(candidateReceipt) && blockedProtected.length === 0;
+    if (validWinner && pick !== null && pickedSubject !== void 0) {
+      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);
+  }
+  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 === void 0 || confirmedGroups.has(artifact.group)) {
+      continue;
+    }
+    settleRecoveredCompeteDecision(process.cwd(), artifact.group, artifact.winner.index);
+  }
+}
+function competeErrorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function dispatchErrorMessage(err) {
+  const message = competeErrorMessage(err);
+  return message.startsWith("dispatch: ") ? message : `dispatch: ${message}`;
+}
+function rejectedReasons(results) {
+  return results.filter((result) => result.status === "rejected").map((result) => result.reason);
+}
+async function runCompete(deps, base, compete, autonomy, timeoutMs, signal) {
+  const requestedRoot = base.cwd !== void 0 && 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) ?? [];
+  recoverCleanupReadyCompeteGroups(requestedRoot);
+  const group = newGateGroupId("compete");
+  const ledgerId = newGateGroupId("ledger");
+  const ledger = { id: ledgerId, sequence: 0 };
+  await openAgentLedger(ledgerId);
+  let ownership = null;
+  const worktrees = [];
+  const runs = [];
+  const decisions = [];
+  const recordDecision = (draft, pending) => {
+    const decision = pending ? finalizePendingGateDecision(pending, draft) : materializePendingGateDecision(stagePendingGateDecision(draft, { resourceRoot: requestedRoot }));
+    decisions.push(decision);
+    return decision;
+  };
+  const ownedRuns = [];
+  const abortErrors = [];
+  let stop = null;
+  let primaryError = null;
+  let winner = null;
+  const currentWinner = () => winner;
+  let timer = null;
+  let signalListenerInstalled = false;
+  const abortOwnedRun = (run) => {
+    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) => {
+    if (stop === null) stop = next;
+    for (const run of ownedRuns) abortOwnedRun(run);
+  };
+  const onSignalAbort = () => requestStop({ message: "compete dispatch aborted" });
+  const throwIfStopped = () => {
+    if (stop !== null) throw new Error(stop.message);
+  };
+  const settleRun = async (handle, request) => {
+    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 !== void 0 ? { resourceRoot: request.cwd } : {}
+        }) : void 0;
+        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, label) => {
+    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 = {
+        runId: handle.runId,
+        settled: false,
+        abortRequested: false,
+        settlement: Promise.resolve(null)
+      };
+      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);
+        }
+      })();
+      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, phase) => {
+    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 = null;
+  try {
+    outcome = await (async () => {
+      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 !== void 0) {
+        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 !== void 0;
+      if (signal?.aborted) onSignalAbort();
+      throwIfStopped();
+      const admissionResults = await Promise.allSettled(
+        worktrees.map((worktree) => {
+          const request = {
+            ...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]
+          };
+          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 });
+        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 !== void 0 && 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 = {
+        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 !== void 0 ? { model: compete.judge.model } : {},
+        ...compete.judge?.target !== void 0 ? { target: compete.judge.target } : {},
+        ...compete.judge?.node !== void 0 ? { node: compete.judge.node } : {},
+        ...base.plan !== void 0 ? { plan: base.plan } : {},
+        ...base.parentToolCallId !== void 0 ? { parentToolCallId: base.parentToolCallId } : {},
+        ...base.reservation !== void 0 ? { 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 === void 0) throw new Error("judge produced no completed run");
+      runs.push(judgeRun);
+      throwIfStopped();
+      const judgeReceipt = judgeRun.receipt;
+      const judgeSummary = judgeRun.summary;
+      const noWinner = (detail) => ({
+        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 === void 0 || 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);
+  if (ownedRuns.some((run) => !run.settled)) {
+    requestStop({ message: "compete lifecycle exited before every worker settled" });
+  }
+  const finalizationErrors = [];
+  await Promise.allSettled(ownedRuns.map((run) => run.settlement));
+  const board = renderAgentLedgerBoard(ledgerId);
+  await closeAgentLedger(ledgerId);
+  finalizationErrors.push(...abortErrors);
+  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) {
+        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 };
+}
+function runApplyWinner(input, planHash, authority, mergeWinner = mergeWinnerBranch, protectedPaths = []) {
+  if (authority === null) {
+    return {
+      kind: "error",
+      message: "dispatch: apply_winner requires a registry-authenticated operator approval or full-auto authority"
+    };
+  }
+  const branch = input.branch;
+  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 = input.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 === void 0 || winnerDecision.artifact.winner === void 0) {
+    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 = () => 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 ${planHash}` : `full-auto applied ${branch} under dispatch plan ${planHash}`
+    })
+  );
+  let confirmation = 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, outcome, maxOutputBytes) {
+  const body = formatDispatchOutput("review", outcome.runs, maxOutputBytes);
+  const details = {
+    ...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 !== void 0 ? { needsDecision: outcome.needsDecision } : {}
+    }
+  };
+  if (outcome.verdict === "pass") {
+    return { kind: "ok", output: `review gate passed after ${outcome.cycles} cycle(s)
+
+${body}`, details };
+  }
+  if (outcome.verdict === "fail") {
+    return { kind: "error", message: `dispatch: review gate failed (reviewer verdict fail)
+
+${body}`, details };
+  }
+  return {
+    kind: "error",
+    message: `dispatch: review gate needs an operator decision: ${outcome.needsDecision ?? "no verdict"}
+
+${body}`,
+    details
+  };
+}
+function competeResult(deps, outcome, autonomy, maxOutputBytes) {
+  const board = outcome.board ?? null;
+  const body = formatDispatchOutput("compete", outcome.runs, maxOutputBytes, board);
+  const details = {
+    ...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 !== void 0 ? { needsDecision: outcome.needsDecision } : {}
+    }
+  };
+  if (outcome.winner?.applied === true) {
+    return {
+      kind: "ok",
+      output: `compete winner candidate ${outcome.winner.index} applied (branch ${outcome.winner.branch} merged)
+
+${body}`,
+      details
+    };
+  }
+  if (outcome.winner !== null && outcome.needsDecision === void 0) {
+    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")}
+
+${body}`, details };
+  }
+  return {
+    kind: "error",
+    message: `dispatch: compete needs an operator decision: ${outcome.needsDecision ?? "no winner"}
+
+${body}`,
+    details
+  };
+}
+async function runDispatchTool(inputDeps, admissionState, args, options) {
+  const deps = {
+    ...inputDeps,
+    runEvents: inputDeps.runEvents ?? createDispatchRunEventRegistry()
+  };
+  const snapshot = admissionState.trustedExecutionSnapshots.get(args);
+  if (snapshot?.kind === "list") {
+    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 (snapshot?.kind === "apply-winner") {
+    const trustedWinnerPlan = admissionState.trustedResolvedPlans.get(args);
+    if (trustedWinnerPlan === void 0) {
+      return { kind: "error", message: "dispatch: trusted winner-application plan is unavailable" };
+    }
+    const confirmation = trustedWinnerPlan.confirmation;
+    if (confirmation !== void 0) {
+      if (snapshot.branch !== confirmation.branch || confirmation.cwd !== void 0 && snapshot.cwd !== confirmation.cwd) {
+        return { kind: "error", message: "dispatch: winner destination differs from the approved plan" };
+      }
+    }
+    const approval = options?.approval;
+    const authority = approval?.actionClass === "dispatch" ? {
+      outcome: "operator-confirmed",
+      requestId: approval.requestId,
+      requestedBy: approval.requestedBy
+    } : deps.getAutonomy?.() === "full-auto" ? { outcome: "full-auto-applied" } : null;
+    let protectedPaths;
+    try {
+      protectedPaths = deps.dispatch.protectedArtifactState?.().artifacts.map((artifact) => artifact.path) ?? [];
+    } catch (error) {
+      return {
+        kind: "error",
+        message: `dispatch: protected artifact state is unavailable: ${competeErrorMessage(error)}`
+      };
+    }
+    const planHash = describeDispatchPlan({
+      apply_winner: { branch: snapshot.branch, cwd: snapshot.cwd },
+      [RESOLVED_DISPATCH_PLAN_ARGUMENT]: trustedWinnerPlan
+    }).hash;
+    return runApplyWinner(snapshot, planHash, authority, deps.competeWorktrees?.mergeWinner, protectedPaths);
+  }
+  if (snapshot?.kind !== "dispatch") {
+    return { kind: "error", message: "dispatch: trusted execution admission snapshot is unavailable" };
+  }
+  const mode = snapshot.mode;
+  if (options?.signal?.aborted) return { kind: "error", message: "dispatch: aborted" };
+  const maxOutputBytes = snapshot.maxOutputBytes;
+  const timeoutMs = snapshot.timeoutMs;
+  let review = snapshot.review === void 0 ? void 0 : structuredClone(snapshot.review);
+  const autonomy = deps.getAutonomy?.() ?? "auto-edit";
+  const authenticatedApproval = options?.approval?.actionClass === "dispatch" ? options.approval : void 0;
+  const trustedResolvedPlan = admissionState.trustedResolvedPlans.get(args) ?? null;
+  const planView = snapshot.planView;
+  const resolvedPlan = trustedResolvedPlan;
+  const reservationOwnerId = admissionState.trustedReservationOwners.get(args);
+  const parentToolCallId = options?.toolCallId;
+  let requests = parentToolCallId === void 0 || parentToolCallId.length === 0 ? structuredClone(snapshot.requests) : snapshot.requests.map((request) => ({ ...structuredClone(request), parentToolCallId }));
+  if (planView.planScale && deps.dispatch.preview !== void 0 && resolvedPlan === null) {
+    return { kind: "error", message: "dispatch: resolved plan is missing after admission" };
+  }
+  if (planView.planScale && autonomy !== "full-auto" && authenticatedApproval === void 0) {
+    return {
+      kind: "error",
+      message: "dispatch: resolved plan requires a registry-authenticated operator approval"
+    };
+  }
+  if (resolvedPlan !== null) {
+    const primaryRole = review !== void 0 ? "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 !== void 0 && task?.role !== void 0 && task.position !== void 0 ? {
+        ...pinned,
+        reservation: {
+          ownerId: reservationOwnerId,
+          memberId: task.stepId ?? `${task.role}-${task.position}`
+        }
+      } : pinned;
+    });
+    if (review !== void 0) {
+      const reviewer = resolvedPlan.tasks.find((task) => task.role === "reviewer");
+      if (reviewer === void 0) {
+        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 = {
+      hash: planView.hash,
+      topology: planView.topology,
+      taskCount: planView.taskCount,
+      approval: authenticatedApproval !== void 0 ? "operator" : "full-auto",
+      source: resolvedPlan?.source === null || resolvedPlan?.source === void 0 ? null : {
+        kind: "scout-transition",
+        runId: resolvedPlan.source.runId,
+        receiptDigest: resolvedPlan.source.receiptDigest,
+        executionPlanHash: resolvedPlan.source.executionPlanHash
+      },
+      ...authenticatedApproval !== void 0 ? {
+        approvalRequestId: authenticatedApproval.requestId,
+        approvalRequestedBy: authenticatedApproval.requestedBy
+      } : {},
+      ...planView.costCeilingUsd !== void 0 ? { 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 !== void 0 ? "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 !== void 0 ? `this call set timeout_ms=${timeoutMs} and nobody would be left to enforce the deadline` : deps.dispatch.detached === void 0 ? "detached batch records are unavailable in this context" : null;
+  const background = createBackgroundSwitch();
+  const backgroundLabel = resolvedPlan?.topology === "fleet" ? "fleet" : review !== void 0 ? "review" : mode;
+  const releaseBackground = registerBackgroundControl(deps, options?.toolCallId, {
+    label: `dispatch (${backgroundLabel})`,
+    refusal: backgroundRefusal,
+    fire: () => background.fire()
+  });
+  try {
+    if (resolvedPlan?.topology === "fleet") {
+      const executionPlan = admissionState.trustedExecutionPlans.get(args);
+      if (executionPlan === void 0 || resolvedPlan.source === null || resolvedPlan.deadlineMs === null || reservationOwnerId === void 0) {
+        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 !== void 0, 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 === void 0 ? {} : { 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 (snapshot.detach) {
+      if (mode !== "parallel") {
+        return { kind: "error", message: `dispatch: detach only supports parallel mode; got '${mode}'` };
+      }
+      if (review !== void 0) {
+        return {
+          kind: "error",
+          message: "dispatch: detach cannot combine with a review gate; run gated dispatch attached"
+        };
+      }
+      if (timeoutMs !== void 0) {
+        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] === void 0) {
+        return { kind: "error", message: COMPETE_SINGLE_TASK_MESSAGE };
+      }
+      if (review !== void 0) {
+        return { kind: "error", message: COMPETE_NO_REVIEW_MESSAGE };
+      }
+      if (snapshot.compete === void 0) {
+        return { kind: "error", message: "dispatch: trusted compete settings are unavailable" };
+      }
+      let compete = structuredClone(snapshot.compete);
+      if (resolvedPlan !== null) {
+        const judge = resolvedPlan.tasks.find((task) => task.role === "judge");
+        if (judge === void 0) {
+          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 !== void 0) {
+      if (requests.length !== 1 || requests[0] === void 0) {
+        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;
+      let board = null;
+      if (mode === "pipeline" && requests.length > 1) {
+        runs = await runPipeline(deps, requests, timeoutMs, options?.signal);
+      } else if (mode === "sequential" || mode === "pipeline" || requests.length === 1) {
+        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}
+
+${output}`,
+          details: dispatchDetails(deps, "pipeline", err.runs)
+        };
+      }
+      return { kind: "error", message: dispatchErrorMessage(err) };
+    }
+  } finally {
+    releaseBackground();
+  }
+}
+async function runSequential(deps, requests, mode, timeoutMs, signal, background) {
+  const runs = [];
+  let expired = false;
+  let activeRunId = null;
+  const abortActive = (bySignal) => {
+    expired = true;
+    if (activeRunId !== null) {
+      deps.dispatch.abort(
+        activeRunId,
+        bySignal ? void 0 : { cause: "timeout", detail: `timed out after ${timeoutMs}ms` }
+      );
+    }
+  };
+  const onSignalAbort = () => abortActive(true);
+  const timer = timeoutMs !== void 0 ? 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", value }));
+      const settled = await Promise.race([completion, background.requested.then(() => ({ kind: "background" }))]);
+      if (settled.kind === "background") {
+        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);
+  }
+}
+function isPipelineStepFailure(receipt) {
+  if (receipt.exitCode !== 0) return true;
+  return receipt.outcome !== void 0 && receipt.outcome !== "succeeded";
+}
+function pipelineFailureReason(receipt) {
+  if (receipt.outcome !== void 0 && receipt.outcome !== "succeeded") return `outcome=${receipt.outcome}`;
+  return `exit=${receipt.exitCode}`;
+}
+async function runPipeline(deps, requests, timeoutMs, signal) {
+  const runs = [];
+  let expired = false;
+  let activeRunId = null;
+  const abortActive = (bySignal) => {
+    expired = true;
+    if (activeRunId !== null) {
+      deps.dispatch.abort(
+        activeRunId,
+        bySignal ? void 0 : { cause: "timeout", detail: `timed out after ${timeoutMs}ms` }
+      );
+    }
+  };
+  const onSignalAbort = () => abortActive(true);
+  const timer = timeoutMs !== void 0 ? setTimeout(() => abortActive(false), timeoutMs) : null;
+  signal?.addEventListener("abort", onSignalAbort, { once: true });
+  try {
+    let previous = 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`}`
+        );
+      }
+      const request = 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);
+  }
+}
+async function runBatch(deps, requests, timeoutMs, signal, background) {
+  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)
+  );
+  const abort = (bySignal) => {
+    const reason = bySignal ? void 0 : { cause: "timeout", detail: `timed out after ${timeoutMs}ms` };
+    for (const runId of handle.assignmentIds) deps.dispatch.abort(runId, reason);
+  };
+  const onSignalAbort = () => abort(true);
+  const timer = timeoutMs !== void 0 ? setTimeout(() => abort(false), timeoutMs) : null;
+  signal?.addEventListener("abort", onSignalAbort, { once: true });
+  let backgrounded = false;
+  try {
+    const completion = registered.completion.then((value) => ({ kind: "completed", value }));
+    const settled = await Promise.race([completion, background.requested.then(() => ({ kind: "background" }))]);
+    if (settled.kind === "background") {
+      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;
+    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);
+  }
+}
+export {
+  runDispatchTool
+};
+//# sourceMappingURL=dispatch-runner-QPRDDBDX.js.map