@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-3NOTLVLG.js

@@ -0,0 +1,3803 @@
+import {
+  assignDuplicateVariantInstanceIds,
+  cleanupSynthesisInputPatches,
+  resolveBasicCompetitionInterruption,
+  resolveSynthesisInputPatchDir,
+  runBasicCompetition,
+  selectWinnerWithJudge
+} from "./chunk-YBHUB4XR.js";
+import {
+  createEvaluationHandleFinalState,
+  finalizeEvaluationHandleAsync,
+  isDurableHandleCompletion,
+  toEvaluationHandleWinnerMetadata,
+  updateEvaluationHandleWithResultAsync
+} from "./chunk-NTD6CSI6.js";
+import {
+  evaluateStageCompletionProof,
+  proofEstablishesSatisfaction,
+  resolveProviderExecutionIntentFromStage,
+  stageHasHostDeterministicCompletionSurface
+} from "./chunk-QAMAV4DT.js";
+import {
+  collectDeclaredStageTargets
+} from "./chunk-45KUJBDI.js";
+import {
+  changesHaveVerifiableCodeSurface
+} from "./chunk-OXK5HA4B.js";
+import {
+  providerReportsUsage,
+  readCostMetricsUnavailableReason,
+  readUsageUnavailableReason
+} from "./chunk-JQUMSIGC.js";
+import {
+  JudgeCoordinator,
+  evaluateMatrixAuthority,
+  extractEvidenceAnchors,
+  generateCompetitionId,
+  isNegativeClaim,
+  resolveMatrixAuthorityPolicy,
+  resolveTypedCompletenessAuthority
+} from "./chunk-DCACX7BV.js";
+import {
+  resolveJudgeModelRoles
+} from "./chunk-ARARVIZK.js";
+import {
+  isAcceptedMatrixVerdict
+} from "./chunk-6PZY2TTU.js";
+import {
+  categorizeFile
+} from "./chunk-QTCLJHLZ.js";
+import {
+  ArtifactNotFoundError,
+  createSecurityBoundary,
+  resolvePromptArtifacts
+} from "./chunk-SK3ZFONO.js";
+import {
+  isProviderInvocationFailure,
+  judgeProviderFailed
+} from "./chunk-UJYDH2MW.js";
+import {
+  deriveAiJudgeInvocationArgs
+} from "./chunk-EJVCDTAN.js";
+import {
+  applyFlywheelModelDefaults
+} from "./chunk-DSRLVYBS.js";
+import {
+  decideStageChangeScope
+} from "./chunk-DS2JZ677.js";
+import {
+  findAllowlistViolations,
+  isPathAllowed,
+  normalizePath
+} from "./chunk-XZOXEIN4.js";
+import {
+  getProjectRoot
+} from "./chunk-6TRD7TEE.js";
+import {
+  JUDGE_FEATURE_FLAGS
+} from "./chunk-ZJB6SQPA.js";
+import {
+  resolveJudgeRunSet
+} from "./chunk-IVZEONFC.js";
+import {
+  filterWorktreeRunSentinelPaths
+} from "./chunk-2NMNFUQA.js";
+import {
+  formatVariantIdentifier,
+  parseVariantIdentifier
+} from "./chunk-TGXXYDL4.js";
+import {
+  isRecoverableCompetitionDiff
+} from "./chunk-SKTFRFQ7.js";
+import {
+  deriveTestVerificationDisplay,
+  gateStatusToDisplayVerdict
+} from "./chunk-R2CKS6WT.js";
+import {
+  deriveVariantOutcome,
+  hasUnavailableTestVerificationEvidence,
+  repairOutcomeCanSupersedeRawTouchedFailure
+} from "./chunk-3OPP2OZB.js";
+import {
+  isUnavailableVerificationFinding
+} from "./chunk-PXKERBKX.js";
+import {
+  prepareUntrackedIntentIndex
+} from "./chunk-QFLBRWCJ.js";
+import {
+  parseDiffGitHeaderPaths,
+  parseUnifiedDiffPathLine
+} from "./chunk-5FKHIKTS.js";
+import {
+  taskVariantId
+} from "./chunk-F55YABKV.js";
+import {
+  readTrackedToolOutputRootsSync,
+  shouldExcludeFile
+} from "./chunk-5EQN56OZ.js";
+import {
+  runVerifyCommands
+} from "./chunk-AHU3FKPA.js";
+import {
+  isUnderRootToolOutputDir
+} from "./chunk-QOIASNEJ.js";
+import {
+  LabPathResolver
+} from "./chunk-C3KCMAJP.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import {
+  isInvalidExplicitConfigError
+} from "./chunk-QJ6OEH4K.js";
+import {
+  normalizeReasoningEffortInput
+} from "./chunk-4BTDUT2S.js";
+import {
+  createExecutionContext
+} from "./chunk-7VRJHTGZ.js";
+import {
+  sanitizeString
+} from "./chunk-CPSVQR2I.js";
+
+// src/automation/flywheel-competition-executor.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import chalk from "chalk";
+
+// src/automation/competition-pick-label.ts
+function competitionPickLabel(successCount) {
+  return successCount === 0 ? "Judge pick (gates failed)" : "Winner";
+}
+
+// src/automation/gate-evidence.ts
+var DETAIL_TAIL_LINES = 6;
+var DETAIL_LINE_MAX_CHARS = 200;
+var GATE_EVIDENCE_ARTIFACT_NAME = "verification-findings";
+function selectFailingGateFindings(findings) {
+  return (findings ?? []).filter(
+    (finding) => finding.severity === "error" || Number.isFinite(finding.exitCode) && finding.exitCode !== 0
+  ).map((finding) => ({
+    ...finding,
+    command: sanitizeString(finding.command),
+    ...finding.outputTail === void 0 ? {} : { outputTail: sanitizeString(finding.outputTail) }
+  }));
+}
+function formatFailingGateDetail(findings) {
+  const failing = selectFailingGateFindings(findings);
+  const first = failing[0];
+  if (!first) return void 0;
+  const others = failing.length - 1;
+  const more = others > 0 ? ` (+${others} more failing gate${others === 1 ? "" : "s"})` : "";
+  const head = isUnavailableVerificationFinding(first) ? `${first.command} unavailable (exit ${first.exitCode})${more}` : `${first.command} exited ${first.exitCode}${more}`;
+  const tail = (first.outputTail ?? "").split(/\r?\n/).map((line) => line.trimEnd()).filter((line) => line.length > 0).slice(-DETAIL_TAIL_LINES).map(
+    (line) => line.length > DETAIL_LINE_MAX_CHARS ? `${line.slice(0, DETAIL_LINE_MAX_CHARS)}...` : line
+  );
+  return tail.length > 0 ? `${head}
+${tail.map((line) => `    ${line}`).join("\n")}` : head;
+}
+function gateEvidenceField(verification) {
+  const failing = selectFailingGateFindings(verification?.findings);
+  return failing.length > 0 ? { verificationFindings: failing } : {};
+}
+async function persistGateEvidenceArtifact(artifactStore, stageId, verification) {
+  const failing = selectFailingGateFindings(verification?.findings);
+  if (failing.length === 0) return;
+  try {
+    await artifactStore.save(stageId, GATE_EVIDENCE_ARTIFACT_NAME, "json", { findings: failing });
+  } catch {
+  }
+}
+
+// src/automation/verification-polarity.ts
+function normalizedSignal(value) {
+  const trimmed = value?.trim().toLowerCase();
+  return trimmed ? trimmed : void 0;
+}
+function testsNotRunWithoutTestableSurface(input) {
+  if (input.testSkipReason !== "no-test-files-changed") return false;
+  const changedFiles = input.changedFiles;
+  if (!changedFiles || changedFiles.length === 0) return false;
+  if (changesHaveVerifiableCodeSurface([...changedFiles])) return false;
+  if (normalizedSignal(input.testStatus) !== "not_run") return false;
+  const raw = normalizedSignal(input.rawTestStatus);
+  if (raw !== void 0 && raw !== "not_run") return false;
+  if (input.exitCode !== void 0 && input.exitCode !== null) return false;
+  if (typeof input.failedTests === "number" && input.failedTests !== 0) return false;
+  return true;
+}
+function hasExplicitVerificationSignal(input) {
+  if (input.verification && typeof input.verification.passed === "boolean") {
+    return true;
+  }
+  if (typeof input.verification?.status === "string" && input.verification.status.trim()) {
+    return true;
+  }
+  if (typeof input.testStatus === "string" && input.testStatus.trim()) {
+    return true;
+  }
+  if (typeof input.rawTestStatus === "string" && input.rawTestStatus.trim()) {
+    return true;
+  }
+  if (typeof input.exitCode === "number") {
+    return true;
+  }
+  if (typeof input.failedTests === "number") {
+    return true;
+  }
+  return false;
+}
+function verificationRecordsBaselineClean(verification) {
+  if (!verification) {
+    return false;
+  }
+  if (verification.passedBaseline === false) {
+    return false;
+  }
+  const status = verification.status?.trim().toLowerCase();
+  if (status === "baseline_clean") {
+    return true;
+  }
+  if (verification.passedBaseline !== true) {
+    return false;
+  }
+  return !status || gateStatusToDisplayVerdict(status) !== "unavailable";
+}
+function verificationPolarityAllowsStageSuccess(input) {
+  if (!hasExplicitVerificationSignal(input)) {
+    return true;
+  }
+  if (verificationRecordsBaselineClean(input.verification)) {
+    return true;
+  }
+  if (input.verification?.passed === false) {
+    return false;
+  }
+  const status = input.verification?.status?.trim().toLowerCase();
+  if (status === "failed" || status === "unavailable") {
+    return false;
+  }
+  if (testsNotRunWithoutTestableSurface(input)) {
+    return !status || gateStatusToDisplayVerdict(status) !== "unavailable";
+  }
+  const hasExplicitTestSignal = typeof input.testStatus === "string" && input.testStatus.trim().length > 0 || typeof input.rawTestStatus === "string" && input.rawTestStatus.trim().length > 0 || typeof input.exitCode === "number" || typeof input.failedTests === "number";
+  if (hasExplicitTestSignal) {
+    const display = deriveTestVerificationDisplay({
+      testStatus: input.testStatus,
+      rawTestStatus: input.rawTestStatus,
+      exitCode: input.exitCode,
+      failedTests: input.failedTests
+    });
+    return display === "passed";
+  }
+  return input.verification?.passed === true || status === "passed";
+}
+
+// src/automation/flywheel-apply-winner.ts
+function toPolarityInput(input) {
+  return {
+    verification: input.verification,
+    testStatus: input.testStatus,
+    rawTestStatus: input.rawTestStatus,
+    exitCode: input.exitCode,
+    failedTests: input.failedTests
+  };
+}
+function classifyVerificationBlocker(input) {
+  if (verificationPolarityAllowsStageSuccess(toPolarityInput(input))) {
+    return void 0;
+  }
+  const status = input.verification?.status?.trim().toLowerCase();
+  const display = deriveTestVerificationDisplay({
+    testStatus: input.testStatus,
+    rawTestStatus: input.rawTestStatus,
+    exitCode: input.exitCode,
+    failedTests: input.failedTests,
+    // A recorded unavailable test run keeps its non-zero exit (missing
+    // toolchain, zero tests collected) without becoming a gate failure.
+    testsUnavailable: hasUnavailableTestVerificationEvidence({
+      testStatus: input.rawTestStatus ?? input.testStatus ?? void 0
+    })
+  });
+  if (status === "failed" || display === "failed") {
+    return "gates-failed";
+  }
+  if (input.verification?.passed === false && status !== "unavailable") {
+    return "gates-failed";
+  }
+  if (status === "unavailable" || display === "unavailable" || input.testStatus === "unavailable" || input.testStatus === "not_run") {
+    return "tests-unavailable";
+  }
+  return "gates-failed";
+}
+function classifyStageValidationFailure(input) {
+  const verificationBlocker = classifyVerificationBlocker(input);
+  if (verificationBlocker) return verificationBlocker;
+  if (input.score < input.threshold) return "below-threshold";
+  return void 0;
+}
+function formatStageValidationFailureMessage(predicate, score, threshold, findings) {
+  const base = formatStageValidationFailureHead(predicate, score, threshold);
+  const detail = formatFailingGateDetail(findings);
+  return detail ? `${base}: ${detail}` : base;
+}
+function describeStageValidationFailure(input) {
+  const predicate = classifyStageValidationFailure(input);
+  return {
+    predicate,
+    message: formatStageValidationFailureMessage(
+      predicate,
+      input.score,
+      input.threshold,
+      input.verification?.findings
+    )
+  };
+}
+function formatStageValidationFailureHead(predicate, score, threshold) {
+  switch (predicate) {
+    case "tests-unavailable":
+      return `Verification unavailable (score ${score}, threshold ${threshold})`;
+    case "gates-failed":
+      return `Gates failed (score ${score}, threshold ${threshold})`;
+    case "below-threshold":
+      return `Score ${score} below threshold ${threshold}`;
+    default:
+      return `Validation did not pass (score ${score}, threshold ${threshold})`;
+  }
+}
+function formatWinnerDeliveryRefusalReason(predicate) {
+  switch (predicate) {
+    case "tests-unavailable":
+      return "tests unavailable";
+    case "gates-failed":
+      return "gates failed";
+    case "below-threshold":
+      return "score below threshold";
+  }
+}
+function winnerHasNoApplicableTests(winner) {
+  if (winner.testStatus !== "not_run") return false;
+  if (winner.testsExecuted?.skipReason !== "no-test-files-changed") return false;
+  const changedFiles = winner.changedFiles ?? [];
+  if (changedFiles.length === 0) return false;
+  return changedFiles.every((file) => categorizeFile(file) === "docs");
+}
+function resolveTrustedCandidateTestStatus(candidate) {
+  const status = candidate.testStatus;
+  if (candidate.repairedTestStatus !== void 0 && (status === "failed" || status === "error" || status === "timeout")) {
+    return candidate.repairedTestStatus;
+  }
+  return status;
+}
+function isExecutedTestFailure(finding) {
+  return finding.kind === "test" && finding.severity === "error" && finding.exitCode !== 0 && finding.exitCode !== 127;
+}
+function isExecutedNonTestGateFailure(finding) {
+  return finding.kind !== "test" && finding.severity === "error" && finding.exitCode !== 0;
+}
+function summaryRecordsUnavailable(summary) {
+  const status = summary.status;
+  if (typeof status === "string") return status.trim().toLowerCase() === "unavailable";
+  return summary.passed === false && (summary.findings ?? []).some(isUnavailableVerificationFinding);
+}
+function classifyCompetitionValidationFailure(result) {
+  const winner = result.winner;
+  const testStatus = winner?.testStatus;
+  const verificationSummary = winner?.verification ?? result.verification;
+  const statusFromTest = testStatus === "unavailable" || testStatus === "not_run" ? "unavailable" : testStatus === "failed" || testStatus === "error" || testStatus === "timeout" ? "failed" : testStatus === "passed" ? "passed" : void 0;
+  const executedGateFailed = verificationSummary?.findings?.some(isExecutedNonTestGateFailure);
+  const aggregateUnavailable = !executedGateFailed && !verificationSummary?.findings?.some(isExecutedTestFailure) && verificationSummary && summaryRecordsUnavailable(verificationSummary);
+  const gateStatus = statusFromTest === "unavailable" && executedGateFailed ? "failed" : aggregateUnavailable && (statusFromTest === void 0 || statusFromTest === "passed") ? "unavailable" : statusFromTest;
+  return classifyStageValidationFailure({
+    success: winner?.success === true,
+    score: winner?.score ?? result.validationScore ?? 0,
+    // Threshold is not persisted on the stage result. A successful winner
+    // whose verification does not block and whose validationPassed is false
+    // is the below-threshold case; a non-success winner without a
+    // verification blocker stays unclassified so the generic fallback remains.
+    threshold: winner?.success === true ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY,
+    verification: verificationSummary ? {
+      passed: verificationSummary.passed && gateStatus !== "failed",
+      status: gateStatus === "unavailable" ? "unavailable" : gateStatus === "failed" ? "failed" : verificationSummary.passed ? "passed" : gateStatus ?? "failed"
+    } : gateStatus ? { passed: gateStatus === "passed", status: gateStatus } : void 0,
+    testStatus,
+    rawTestStatus: testStatus,
+    exitCode: winner?.testsExecuted?.exitCode
+  });
+}
+function resolveWinnerDeliveryRefusalReason(result) {
+  if (result.validationPassed !== true) {
+    const predicate = classifyCompetitionValidationFailure(result);
+    if (predicate) return formatWinnerDeliveryRefusalReason(predicate);
+    return "validation did not pass";
+  }
+  if (result.winner?.success !== true) return "selected winner is not successful";
+  const invariantStatus = result.winner.mergeInvariantValidation?.status;
+  if (invariantStatus !== void 0 && invariantStatus !== "passed") {
+    return "merge invariant validation did not pass";
+  }
+  return void 0;
+}
+function normalizeAllowlistEntriesForMatching(allowlist) {
+  return allowlist.map((entry) => {
+    const hadTrailingSlash = entry.endsWith("/");
+    const normalized = normalizePath(entry);
+    if (hadTrailingSlash && !normalized.endsWith("/")) {
+      return `${normalized}/`;
+    }
+    return normalized;
+  });
+}
+function isNullDiffEndpoint(filePath) {
+  return normalizePath(filePath) === "/dev/null";
+}
+function parseDiffGitHeader(line) {
+  const parsed = parseDiffGitHeaderPaths(line);
+  if (!parsed) return null;
+  return {
+    aPath: normalizePath(parsed.aPath),
+    bPath: normalizePath(parsed.bPath)
+  };
+}
+function resolveDiffBlockEndpoints(header, blockLines) {
+  let aPath = header.aPath;
+  let bPath = header.bPath;
+  let aIsNull = isNullDiffEndpoint(aPath);
+  let bIsNull = isNullDiffEndpoint(bPath);
+  let sawRenameOrCopyMarker = false;
+  const markerKinds = /* @__PURE__ */ new Set();
+  let markerFrom;
+  let markerTo;
+  const parseMarkerPath = (line, prefix) => {
+    const token = line.slice(prefix.length);
+    if (!token) return void 0;
+    const aToken = token.startsWith('"') ? `"a/${token.slice(1)}` : `a/${token}`;
+    const bToken = token.startsWith('"') ? `"b/${token.slice(1)}` : `b/${token}`;
+    return parseDiffGitHeaderPaths(`diff --git ${aToken} ${bToken}`)?.aPath;
+  };
+  for (const line of blockLines) {
+    if (line.startsWith("@@")) break;
+    if (line.startsWith("rename from ")) {
+      sawRenameOrCopyMarker = true;
+      markerKinds.add("rename");
+      markerFrom = parseMarkerPath(line, "rename from ");
+      continue;
+    }
+    if (line.startsWith("rename to ")) {
+      sawRenameOrCopyMarker = true;
+      markerKinds.add("rename");
+      markerTo = parseMarkerPath(line, "rename to ");
+      continue;
+    }
+    if (line.startsWith("copy from ")) {
+      sawRenameOrCopyMarker = true;
+      markerKinds.add("copy");
+      markerFrom = parseMarkerPath(line, "copy from ");
+      continue;
+    }
+    if (line.startsWith("copy to ")) {
+      sawRenameOrCopyMarker = true;
+      markerKinds.add("copy");
+      markerTo = parseMarkerPath(line, "copy to ");
+      continue;
+    }
+    if (line.startsWith("--- ")) {
+      const parsed = parseUnifiedDiffPathLine(line);
+      if (parsed === "/dev/null") {
+        aIsNull = true;
+      } else if (parsed) {
+        aPath = normalizePath(parsed);
+        aIsNull = false;
+      }
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      const parsed = parseUnifiedDiffPathLine(line);
+      if (parsed === "/dev/null") {
+        bIsNull = true;
+      } else if (parsed) {
+        bPath = normalizePath(parsed);
+        bIsNull = false;
+      }
+    }
+  }
+  if (aIsNull) aPath = "/dev/null";
+  if (bIsNull) bPath = "/dev/null";
+  const isRenameOrCopy = sawRenameOrCopyMarker || !aIsNull && !bIsNull && aPath !== bPath;
+  const markerPaths = [markerFrom, markerTo].filter((value) => Boolean(value));
+  const markersConsistent = !sawRenameOrCopyMarker || markerKinds.size === 1 && markerFrom === aPath && markerTo === bPath;
+  return { aPath, bPath, isRenameOrCopy, markersConsistent, markerPaths };
+}
+function isDiffBlockAllowlisted(endpoints, allowlist) {
+  if (!endpoints.markersConsistent) return false;
+  const aNull = isNullDiffEndpoint(endpoints.aPath);
+  const bNull = isNullDiffEndpoint(endpoints.bPath);
+  if (aNull && bNull) return false;
+  if (aNull) return isPathAllowed(endpoints.bPath, allowlist);
+  if (bNull) return isPathAllowed(endpoints.aPath, allowlist);
+  if (endpoints.isRenameOrCopy || endpoints.aPath !== endpoints.bPath) {
+    return isPathAllowed(endpoints.aPath, allowlist) && isPathAllowed(endpoints.bPath, allowlist);
+  }
+  return isPathAllowed(endpoints.aPath, allowlist);
+}
+function disallowedEndpointsForBlock(endpoints, allowlist) {
+  if (isDiffBlockAllowlisted(endpoints, allowlist)) {
+    return [];
+  }
+  const violations = /* @__PURE__ */ new Set();
+  if (!isNullDiffEndpoint(endpoints.aPath) && !isPathAllowed(endpoints.aPath, allowlist)) {
+    violations.add(endpoints.aPath);
+  }
+  if (!isNullDiffEndpoint(endpoints.bPath) && !isPathAllowed(endpoints.bPath, allowlist)) {
+    violations.add(endpoints.bPath);
+  }
+  for (const markerPath of endpoints.markerPaths) {
+    if (!isPathAllowed(markerPath, allowlist)) violations.add(markerPath);
+  }
+  if (violations.size === 0) {
+    if (!isNullDiffEndpoint(endpoints.aPath)) violations.add(endpoints.aPath);
+    if (!isNullDiffEndpoint(endpoints.bPath)) violations.add(endpoints.bPath);
+  }
+  return [...violations];
+}
+function iterateDiffFileBlocks(diffText, onBlock) {
+  let currentBlock = [];
+  let currentHeader = null;
+  const flush = () => {
+    if (currentBlock.length === 0 || !currentHeader) {
+      currentBlock = [];
+      currentHeader = null;
+      return;
+    }
+    onBlock(currentHeader, currentBlock);
+    currentBlock = [];
+    currentHeader = null;
+  };
+  for (const line of diffText.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      flush();
+      currentBlock = [line];
+      currentHeader = parseDiffGitHeader(line);
+      continue;
+    }
+    if (currentBlock.length === 0) continue;
+    currentBlock.push(line);
+  }
+  flush();
+}
+function findDisallowedDiffEndpoints(diffText, allowlist) {
+  const normalizedAllowlist = normalizeAllowlistEntriesForMatching(allowlist);
+  const violations = /* @__PURE__ */ new Set();
+  iterateDiffFileBlocks(diffText, (header, blockLines) => {
+    const endpoints = resolveDiffBlockEndpoints(header, blockLines);
+    for (const path2 of disallowedEndpointsForBlock(endpoints, normalizedAllowlist)) {
+      violations.add(path2);
+    }
+  });
+  return [...violations];
+}
+function filterUnifiedDiffToAllowlist(diffText, allowlist) {
+  const normalizedAllowlist = normalizeAllowlistEntriesForMatching(allowlist);
+  const fileBlocks = [];
+  iterateDiffFileBlocks(diffText, (header, blockLines) => {
+    const endpoints = resolveDiffBlockEndpoints(header, blockLines);
+    if (isDiffBlockAllowlisted(endpoints, normalizedAllowlist)) {
+      fileBlocks.push(blockLines.join("\n"));
+    }
+  });
+  const filtered = fileBlocks.join("\n");
+  if (filtered.trim().length === 0) return "";
+  return filtered.endsWith("\n") ? filtered : `${filtered}
+`;
+}
+function shouldRestrictWinnerPatchToAllowlist(mode, allowlist) {
+  if (allowlist.length === 0) return false;
+  return mode === "strict" || mode === "filter";
+}
+function applyWinnerAllowlistFilter(patch, allowlist, mode) {
+  if (!shouldRestrictWinnerPatchToAllowlist(mode, allowlist)) {
+    return patch;
+  }
+  return filterUnifiedDiffToAllowlist(patch, [...allowlist]);
+}
+function assertWinnerPatchAllowlistEndpoints(patch, allowlist, mode) {
+  if (!shouldRestrictWinnerPatchToAllowlist(mode, allowlist)) {
+    return;
+  }
+  if (patch.trim().length === 0) {
+    return;
+  }
+  const violations = findDisallowedDiffEndpoints(patch, [...allowlist]);
+  if (violations.length === 0) {
+    return;
+  }
+  throw new Error(
+    `Winner patch has non-allowlisted endpoint(s) under ${mode} allowlist mode: ${violations.join(", ")}`
+  );
+}
+async function loadWinnerVariantResult(result, stageId, artifactStore) {
+  if (!result.winner?.resultArtifactPath || !artifactStore) {
+    return void 0;
+  }
+  const raw = await artifactStore.load(result.winner.resultArtifactPath, stageId);
+  const parsed = JSON.parse(raw);
+  const variantResult = parsed && typeof parsed === "object" && "variantResult" in parsed ? parsed.variantResult : void 0;
+  return variantResult && typeof variantResult === "object" ? variantResult : void 0;
+}
+function nonEmptyPatch(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+async function diffWinnerWorktree(worktreePath, pathspec, baseRef = "HEAD") {
+  if (!worktreePath) return void 0;
+  const args = ["diff", "--binary", baseRef];
+  if (pathspec.length > 0) {
+    args.push("--", ...pathspec);
+  }
+  const intentIndex = await prepareUntrackedIntentIndex({ worktreePath });
+  try {
+    const diff = await execGit(args, {
+      cwd: worktreePath,
+      timeoutMs: 0,
+      stripFinalNewline: false,
+      ...intentIndex.indexPath ? { env: { GIT_INDEX_FILE: intentIndex.indexPath } } : {}
+    });
+    if (diff.exitCode !== 0) throw new Error(diff.stderr);
+    return nonEmptyPatch(diff.stdout);
+  } finally {
+    await intentIndex.dispose();
+  }
+}
+async function resolveWinnerPatch(params) {
+  const variantResult = await loadWinnerVariantResult(
+    params.result,
+    params.stageId,
+    params.artifactStore
+  );
+  const storedPatch = nonEmptyPatch(variantResult?.worktreeDiff);
+  const artifactPatchUsable = storedPatch !== void 0 && variantResult?.worktreeDiffReplayable !== false && isRecoverableCompetitionDiff(storedPatch);
+  const artifactPatch = artifactPatchUsable ? storedPatch : void 0;
+  const artifactRejected = storedPatch !== void 0 && !artifactPatchUsable;
+  const truncatedError = () => new Error(
+    "Winner diff truncated for context budget and no retained winner worktree is available to recover the full patch"
+  );
+  const baselineRef = typeof variantResult?.baselineRef === "string" && variantResult.baselineRef.length > 0 ? variantResult.baselineRef : void 0;
+  if (artifactRejected && !baselineRef) throw truncatedError();
+  const diffBase = artifactRejected ? baselineRef : void 0;
+  if (artifactPatch && params.filterTiming === "after-resolution") {
+    return {
+      patch: applyWinnerAllowlistFilter(artifactPatch, params.allowlist, params.allowlistMode)
+    };
+  }
+  if (artifactPatch) {
+    const filteredPatch = applyWinnerAllowlistFilter(
+      artifactPatch,
+      params.allowlist,
+      params.allowlistMode
+    );
+    if (filteredPatch.trim().length > 0) {
+      return { patch: filteredPatch };
+    }
+  }
+  const fallbackPathspec = params.filterTiming === "before-fallback" ? params.fallbackDiffPathspec ?? [] : [];
+  const retainedPatch = await diffWinnerWorktree(
+    typeof variantResult?.retainedWorktreePath === "string" ? variantResult.retainedWorktreePath : void 0,
+    fallbackPathspec,
+    diffBase
+  );
+  if (retainedPatch) {
+    return {
+      patch: params.filterTiming === "after-resolution" ? applyWinnerAllowlistFilter(retainedPatch, params.allowlist, params.allowlistMode) : retainedPatch
+    };
+  }
+  const winnerPatch = await diffWinnerWorktree(
+    params.result.winner?.worktreePath,
+    fallbackPathspec,
+    diffBase
+  );
+  if (!winnerPatch) {
+    if (artifactRejected) throw truncatedError();
+    return void 0;
+  }
+  return {
+    patch: params.filterTiming === "after-resolution" ? applyWinnerAllowlistFilter(winnerPatch, params.allowlist, params.allowlistMode) : winnerPatch
+  };
+}
+async function applyCompetitionWinnerPatch(params) {
+  const resolvedPatch = await resolveWinnerPatch(params);
+  const patch = resolvedPatch?.patch;
+  if (!patch || patch.trim().length === 0) {
+    return { applied: false };
+  }
+  const normalizedPatch = patch.endsWith("\n") ? patch : `${patch}
+`;
+  assertWinnerPatchAllowlistEndpoints(normalizedPatch, params.allowlist, params.allowlistMode);
+  if (params.artifactStore) {
+    try {
+      await params.artifactStore.save(params.stageId, "winnerDiff", "diff", normalizedPatch);
+    } catch {
+    }
+  }
+  try {
+    const applied = await execGit(["apply", "--3way", "--whitespace=nowarn", "-"], {
+      cwd: params.targetWorktreePath,
+      timeoutMs: 0,
+      input: normalizedPatch
+    });
+    if (applied.exitCode !== 0) throw new Error(applied.stderr);
+  } catch (applyError) {
+    try {
+      const reversed = await execGit(["apply", "--reverse", "--check", "-"], {
+        cwd: params.targetWorktreePath,
+        timeoutMs: 0,
+        input: normalizedPatch
+      });
+      if (reversed.exitCode !== 0) throw new Error(reversed.stderr);
+      params.onAlreadyApplied?.();
+    } catch {
+      throw applyError;
+    }
+  }
+  return { applied: true, normalizedPatch };
+}
+
+// src/automation/flywheel-competition-identity.ts
+var admissions = /* @__PURE__ */ new WeakMap();
+function admitFlywheelVariantSpecs(specs, configs) {
+  return specs.map((spec, index) => {
+    const config = configs[index];
+    const admitted = { ...spec, model: config.model };
+    admissions.set(admitted, { config });
+    return admitted;
+  });
+}
+function recordedVariant(result) {
+  const parsed = parseVariantIdentifier(result.variant ?? "");
+  return parsed.provider === result.provider && parsed.executionMode ? parsed : {};
+}
+function recordedEffort(result) {
+  return normalizeReasoningEffortInput(
+    recordedVariant(result).reasoningEffort ?? result.requestedReasoningEffort
+  );
+}
+function recordedModels(result) {
+  const canonical = recordedVariant(result).model;
+  return [
+    result.model,
+    result.resolvedModel,
+    canonical === "default" ? void 0 : canonical
+  ].filter((model) => model !== void 0);
+}
+function configMatchesResult(config, result) {
+  if (config.provider !== result.provider) return false;
+  if (config.variantInstanceId !== result.variantInstanceId) return false;
+  if (result.executionMode && config.executionMode !== result.executionMode) return false;
+  const canonical = parseVariantIdentifier(formatVariantIdentifier(config));
+  if (config.model) {
+    const expectedModels = [config.model, canonical.model, config.fallbackModel];
+    const models = result.modelInput ? [result.modelInput] : recordedModels(result);
+    if (models.length > 0 && !models.some((model) => expectedModels.includes(model))) return false;
+  }
+  const effort = normalizeReasoningEffortInput(config.modelReasoningEffort);
+  const recorded = recordedEffort(result);
+  return recorded === void 0 || effort === recorded;
+}
+function bindFlywheelVariantResults(specs, results) {
+  const matches = specs.map((spec) => {
+    const config = admissions.get(spec).config;
+    const compatible = results.filter((result) => configMatchesResult(config, result));
+    const exact = compatible.filter(
+      (result) => (result.modelInput ?? result.model ?? recordedVariant(result).model) === config.model && recordedEffort(result) === normalizeReasoningEffortInput(config.modelReasoningEffort)
+    );
+    return exact.length > 0 ? exact : compatible;
+  });
+  for (const [index, spec] of specs.entries()) {
+    const possible = matches[index];
+    const result = possible[0];
+    if (possible.length > 1 || result && matches.filter((m) => m.includes(result)).length > 1) {
+      throw new Error(`Ambiguous competition execution identity for ${variantIdForSpec(spec)}`);
+    }
+    admissions.get(spec).result = result;
+  }
+}
+function specMatchesResult(spec, result) {
+  if (spec.provider !== result.provider) return false;
+  const models = result.modelInput ? [result.modelInput] : recordedModels(result);
+  if (spec.model !== void 0 && !models.includes(spec.model)) return false;
+  if (spec.executionMode && result.executionMode && spec.executionMode !== result.executionMode) {
+    return false;
+  }
+  const effort = normalizeReasoningEffortInput(spec.reasoning);
+  const recorded = recordedEffort(result);
+  return effort === void 0 || recorded === void 0 || effort === recorded;
+}
+function matchVariantResult(spec, results) {
+  const admission = admissions.get(spec);
+  if (admission) {
+    return admission.result && results.includes(admission.result) ? admission.result : void 0;
+  }
+  const compatible = results.filter((result) => specMatchesResult(spec, result));
+  const effort = normalizeReasoningEffortInput(spec.reasoning);
+  const exact = effort === void 0 ? [] : compatible.filter((result) => recordedEffort(result) === effort);
+  const matches = exact.length > 0 ? exact : compatible;
+  return matches.length === 1 && !matches[0].variantInstanceId ? matches[0] : void 0;
+}
+function candidateMatchesVariantResult(candidate, result) {
+  const admission = admissions.get(candidate.variant);
+  if (!admission) return !result.variantInstanceId && specMatchesResult(candidate.variant, result);
+  const bound = admission.result;
+  if (!bound || bound.provider !== result.provider) return false;
+  if (bound.variantInstanceId !== result.variantInstanceId) return false;
+  if (bound.modelInput && result.modelInput && bound.modelInput !== result.modelInput) return false;
+  if (bound.model && result.model && bound.model !== result.model && bound.resolvedModel !== result.model && bound.model !== result.resolvedModel)
+    return false;
+  if (bound.executionMode && result.executionMode && bound.executionMode !== result.executionMode)
+    return false;
+  const effort = recordedEffort(bound);
+  const recorded = recordedEffort(result);
+  return effort === void 0 || recorded === void 0 || effort === recorded;
+}
+function findCandidateForVariantResult(candidates, result) {
+  const matches = candidates.filter(
+    (candidate) => candidateMatchesVariantResult(candidate, result)
+  );
+  return matches.length === 1 ? matches[0] : void 0;
+}
+function variantIdForSpec(spec) {
+  const admission = admissions.get(spec);
+  return admission ? `${formatVariantIdentifier(admission.config)}#${admission.config.variantInstanceId ?? ""}` : `${spec.provider ?? ""}:${spec.model ?? ""}`;
+}
+function candidateScoreId(candidate) {
+  return admissions.has(candidate.variant) ? variantIdForSpec(candidate.variant) : [candidate.variant.provider, candidate.variant.model].filter(Boolean).join(":");
+}
+function reconcileJudgeRationaleWinner(packet, judgedCandidate, finalCandidate, hasJudgeVerdict) {
+  const finalWinnerId = finalCandidate ? candidateScoreId(finalCandidate) : "none";
+  if ((packet.winnerId ?? "none") === finalWinnerId) return packet;
+  const selectionChanged = hasJudgeVerdict && judgedCandidate !== finalCandidate;
+  return {
+    ...packet,
+    rawWinnerId: packet.rawWinnerId ?? packet.winnerId ?? void 0,
+    winnerId: finalWinnerId,
+    ...selectionChanged ? { winnerOverridden: true } : {}
+  };
+}
+function observedVariantSpec(result) {
+  return { provider: result.provider, model: result.model, reasoning: recordedEffort(result) };
+}
+
+// src/automation/flywheel-judge-preflight.ts
+function validateWorkflowJudgeModels(config, workerCwd) {
+  const mainJudge = config.judgeConfig?.disableAiJudge !== true;
+  const coverageTieJudge = Boolean(
+    workerCwd && config.judgeConfig && config.candidateGate?.coverage?.targets?.length
+  );
+  if (config.variants.length < 2 || !mainJudge && !coverageTieJudge) return;
+  try {
+    resolveJudgeModelRoles({
+      allowUnsafeModel: config.judgeConfig?.allowUnsafeModel === true,
+      activeJudgeTypes: resolveJudgeRunSet(
+        deriveAiJudgeInvocationArgs(config.judgeConfig),
+        JUDGE_FEATURE_FLAGS.JUDGE_PROFILE === "shadow"
+      )
+    });
+  } catch (error) {
+    if (isInvalidExplicitConfigError(error)) throw error;
+    throw new Error(
+      "Workflow judges require configured quality models. Correct the judge configuration, or use build run competition with --judge-force-model for deliberate fast-model judging.\n" + (error instanceof Error ? error.message : String(error)),
+      { cause: error }
+    );
+  }
+}
+
+// src/automation/flywheel-to-core-verification-finding.ts
+function toCoreVerificationFinding(finding) {
+  const kind = finding.kind === "coverage" ? "other" : finding.kind;
+  const outputParts = [];
+  if (finding.kind === "coverage") {
+    const coverageDetail = finding.outputTail?.trim() ? finding.outputTail.trim() : finding.command ? `Coverage observation for ${finding.command}` : "Coverage observation";
+    outputParts.push(
+      coverageDetail.toLowerCase().includes("coverage") ? coverageDetail : `Coverage: ${coverageDetail}`
+    );
+  } else if (finding.outputTail) {
+    outputParts.push(finding.outputTail);
+  }
+  if (finding.recommendedNextStep) {
+    const next = finding.recommendedNextStep.trim();
+    if (next && !outputParts.some((part) => part.includes(next))) {
+      outputParts.push(next);
+    }
+  }
+  const mapped = {
+    kind,
+    command: finding.command,
+    exitCode: finding.exitCode,
+    severity: finding.severity
+  };
+  if (outputParts.length > 0) {
+    mapped.outputTail = outputParts.join("\n");
+  }
+  return mapped;
+}
+
+// src/automation/flywheel-competition-executor.ts
+var CANDIDATE_GATE_COMMAND_TIMEOUT_MS = 5 * 60 * 1e3;
+function isNoChangesDetectedError(errorMessage) {
+  return Boolean(errorMessage?.includes("No changes detected (git status clean)"));
+}
+function generateCandidateFeedback(variantEvaluation, result) {
+  if (!variantEvaluation && !result) return void 0;
+  const parts = [];
+  const score = variantEvaluation?.qualityScore ?? result.judgeScore ?? result.completeness;
+  if (score !== void 0) {
+    parts.push(`Score: ${Number(score).toFixed(1)}/100`);
+  }
+  const changedFiles = extractChangedFilesFromResult(result);
+  const fileCount = changedFiles.length;
+  const linesAdded = result.gitMetrics?.linesAdded ?? result.linesAdded ?? 0;
+  const linesDeleted = result.gitMetrics?.linesDeleted ?? result.linesRemoved ?? 0;
+  if (fileCount > 0 || linesAdded > 0 || linesDeleted > 0) {
+    parts.push(`Changes: ${fileCount} file(s), +${linesAdded}/-${linesDeleted} lines`);
+  }
+  const testStatus = result.testStatus;
+  if (testStatus) {
+    parts.push(`Tests: ${testStatus}`);
+  }
+  const strengths = variantEvaluation?.strengths;
+  if (strengths && strengths.length > 0) {
+    const topStrengths = strengths.slice(0, 2).join("; ");
+    parts.push(`Strengths: ${topStrengths}`);
+  }
+  const weaknesses = variantEvaluation?.weaknesses;
+  if (weaknesses && weaknesses.length > 0) {
+    const topWeaknesses = weaknesses.slice(0, 2).join("; ");
+    parts.push(`Areas for improvement: ${topWeaknesses}`);
+  }
+  const cq = variantEvaluation?.codeQuality;
+  if (cq) {
+    const metrics = [];
+    if (cq.correctness !== void 0) metrics.push(`correctness=${cq.correctness}`);
+    if (cq.completeness !== void 0) metrics.push(`completeness=${cq.completeness}`);
+    if (metrics.length > 0) {
+      parts.push(`Quality: ${metrics.join(", ")}`);
+    }
+  }
+  return parts.length > 0 ? `${parts.join(". ")}.` : void 0;
+}
+function extractChangedFilesFromResult(result) {
+  if ("changedFiles" in result && Array.isArray(result.changedFiles)) {
+    return result.changedFiles;
+  }
+  const statusLines = result.worktreeSummary?.statusLines;
+  if (statusLines && Array.isArray(statusLines) && statusLines.length > 0) {
+    return statusLines.map((line) => extractChangedFileFromStatusLine(String(line))).filter((line) => Boolean(line));
+  }
+  const filesChanged = result.gitMetrics?.filesChanged;
+  if (typeof filesChanged === "number" && filesChanged > 0) {
+    return Array.from({ length: filesChanged }, (_, i) => `file${i + 1}`);
+  }
+  return [];
+}
+function resultHasChangeTracking(result) {
+  if ("changedFiles" in result && Array.isArray(result.changedFiles)) {
+    return true;
+  }
+  const statusLines = result.worktreeSummary?.statusLines;
+  if (Array.isArray(statusLines)) {
+    return true;
+  }
+  return typeof result.gitMetrics?.filesChanged === "number";
+}
+function extractChangedFileFromStatusLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  const arrowIdx = trimmed.lastIndexOf("->");
+  if (arrowIdx !== -1) {
+    const candidate = trimmed.slice(arrowIdx + 2).trim();
+    return candidate || null;
+  }
+  const match = trimmed.match(/^[MADRCU?! ]{1,2}\s*(.+)$/);
+  return match?.[1]?.trim() ?? null;
+}
+function candidateHasChangedFiles(candidate) {
+  return Array.isArray(candidate.changedFiles) && candidate.changedFiles.length > 0;
+}
+function candidateHasConcreteZeroChanges(candidate) {
+  return candidate.changeTrackingAvailable === true && !candidateHasChangedFiles(candidate);
+}
+function stageHasDeterministicChecks(stage) {
+  return stageHasHostDeterministicCompletionSurface(stage);
+}
+function renderCandidateGateCommand(command, candidate) {
+  return command.replaceAll("{{provider}}", shellArg(candidate.variant.provider)).replaceAll("{{model}}", shellArg(candidate.variant.model ?? "")).replaceAll("{{variant}}", shellArg(formatCompetitionCandidateVariantDisplay(candidate)));
+}
+function formatCompetitionCandidateVariantDisplay(candidate) {
+  return formatCompetitionVariantDisplay(candidate.variant);
+}
+function formatCompetitionVariantDisplay(variant) {
+  const effort = normalizeReasoningEffortInput(variant.reasoning);
+  const parts = [variant.provider, variant.model, effort ? `effort-${effort}` : void 0].filter(
+    (part) => typeof part === "string" && part.length > 0
+  );
+  return parts.join(":");
+}
+function shellArg(value) {
+  if (/^[A-Za-z0-9._:@/+,-]+$/.test(value)) {
+    return value;
+  }
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+async function validateWorktreeAgainstStageChecks(stage, worktreePath, stdout, options) {
+  if (!stageHasHostDeterministicCompletionSurface(stage)) return false;
+  const proof = await evaluateStageCompletionProof({
+    stage,
+    worktreePath,
+    stdout,
+    attemptChangedFiles: options?.attemptChangedFiles ?? [],
+    allowlist: options?.allowlist ?? computeExpectedAllowlist(stage),
+    stageId: stage.id
+  });
+  return proofEstablishesSatisfaction(proof);
+}
+function getVariantTelemetryStatePath(taskId, provider, model, mode, reasoningEffort) {
+  const variantKey = taskVariantId(
+    taskId,
+    provider,
+    model,
+    mode,
+    void 0,
+    void 0,
+    reasoningEffort
+  );
+  return path.join(
+    LabPathResolver.getInstance().getVariantStateDir(path.join(getProjectRoot(), ".build-project")),
+    `${variantKey}.json`
+  );
+}
+function getValueAtPath(root, keys) {
+  let current = root;
+  for (const key of keys) {
+    if (!current || typeof current !== "object") return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function getFiniteNumberAtPath(root, keys) {
+  const value = getValueAtPath(root, keys);
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function getStringAtPath(root, keys) {
+  const value = getValueAtPath(root, keys);
+  return typeof value === "string" ? value : void 0;
+}
+function extractNativeObservedCostFromVariantState(state) {
+  return getFiniteNumberAtPath(state, ["result", "totalCostUsd"]) ?? getFiniteNumberAtPath(state, ["result", "total_cost_usd"]) ?? getFiniteNumberAtPath(state, ["result", "totalCost"]) ?? getFiniteNumberAtPath(state, ["result", "total_cost"]) ?? null;
+}
+function extractCostMetricsAmountFromVariantState(state) {
+  return getFiniteNumberAtPath(state, ["costMetrics", "totalCostUsd"]) ?? getFiniteNumberAtPath(state, ["costMetrics", "totalCost"]) ?? null;
+}
+function resolveCostMetricsUnavailableReason(costMetrics) {
+  if (!costMetrics || typeof costMetrics !== "object") {
+    return void 0;
+  }
+  const usageReason = readUsageUnavailableReason({ costMetrics });
+  if (usageReason !== void 0) {
+    return usageReason;
+  }
+  const reason = readCostMetricsUnavailableReason(
+    costMetrics
+  );
+  if (reason !== void 0) {
+    return reason;
+  }
+  if (costMetrics.pricingStatus === "error") {
+    return "pricing_unavailable";
+  }
+  return void 0;
+}
+function markCandidateCostUnavailable(candidate, reason) {
+  candidate.cost = 0;
+  candidate.costUnavailableReason = reason;
+}
+async function hydrateCandidateCostsFromTelemetry(taskId, candidates, stageIdForLogs, verbose) {
+  await Promise.all(
+    candidates.map(async (candidate) => {
+      if (!candidate.success) return;
+      if (typeof candidate.cost === "number" && Number.isFinite(candidate.cost) && candidate.costUnavailableReason === void 0) {
+        return;
+      }
+      if (typeof candidate.cost === "number" && Number.isFinite(candidate.cost) && candidate.cost > 0) {
+        candidate.costUnavailableReason = void 0;
+        return;
+      }
+      const provider = candidate.variant.provider;
+      if (!provider) return;
+      if (!providerReportsUsage(provider)) {
+        candidate.costUnavailableReason = candidate.costUnavailableReason ?? "provider_not_reported";
+        return;
+      }
+      const variantStatePath = getVariantTelemetryStatePath(
+        taskId,
+        provider,
+        candidate.variant.model,
+        candidate.variant.executionMode,
+        normalizeReasoningEffortInput(candidate.variant.reasoning)
+      );
+      try {
+        const raw = await fs.readFile(variantStatePath, "utf8");
+        const state = JSON.parse(raw);
+        const nativeObservedCost = extractNativeObservedCostFromVariantState(state);
+        const metricsCost = extractCostMetricsAmountFromVariantState(state);
+        const costMetrics = getValueAtPath(state, ["costMetrics"]);
+        const unavailableReason = resolveCostMetricsUnavailableReason(costMetrics);
+        if (typeof nativeObservedCost === "number") {
+          candidate.cost = nativeObservedCost;
+          candidate.costUnavailableReason = void 0;
+          return;
+        }
+        if (typeof metricsCost === "number" && metricsCost > 0) {
+          candidate.cost = metricsCost;
+          candidate.costUnavailableReason = void 0;
+          return;
+        }
+        if (unavailableReason !== void 0) {
+          markCandidateCostUnavailable(candidate, unavailableReason);
+          return;
+        }
+        if (typeof metricsCost === "number") {
+          candidate.cost = metricsCost;
+          candidate.costUnavailableReason = void 0;
+          return;
+        }
+        markCandidateCostUnavailable(
+          candidate,
+          candidate.costUnavailableReason ?? "provider_not_reported"
+        );
+      } catch {
+        markCandidateCostUnavailable(
+          candidate,
+          candidate.costUnavailableReason ?? "provider_not_reported"
+        );
+      }
+      if (verbose) {
+        console.warn(
+          chalk.yellow(
+            `   [${stageIdForLogs}] Unable to hydrate cost from telemetry for ${formatCompetitionCandidateVariantDisplay(candidate)}`
+          )
+        );
+      }
+    })
+  );
+}
+function variantSpecToConfig(spec, executionIntent, stage, defaultProviderExecutionTransport, executionContract) {
+  const model = spec.model ?? applyFlywheelModelDefaults(stage, spec.provider);
+  const modelReasoningEffort = normalizeReasoningEffortInput(spec.reasoning);
+  return {
+    provider: spec.provider,
+    model,
+    ...modelReasoningEffort ? { modelReasoningEffort } : {},
+    // Inert slot: variant strategies were removed as a behavioral axis (ADR-025).
+    // A `strategy` in workflow YAML is accepted and ignored.
+    ...executionContract ? { promptContractOverride: executionContract } : {},
+    executionMode: "local",
+    // Competition stages always run locally
+    executionIntent,
+    ...spec.providerExecutionTransport ?? stage.providerExecutionTransport ?? defaultProviderExecutionTransport ? {
+      executionTransport: spec.providerExecutionTransport ?? stage.providerExecutionTransport ?? defaultProviderExecutionTransport
+    } : {},
+    allowEmptyResults: stage.allowEmptyResults,
+    isBasicCompetition: true,
+    // Don't auto-commit - flywheel manages commits
+    disableAutoCommit: true,
+    structuredFileTargets: computeExpectedAllowlist(stage)
+  };
+}
+function assertNoDuplicateVariantSpecs(variants, options) {
+  if (options.allowDuplicates) return;
+  const keyToVariants = /* @__PURE__ */ new Map();
+  for (const variant of variants) {
+    const modelKey = variant.model ?? "default";
+    const effortKey = variant.modelReasoningEffort ?? "default";
+    const key = `${variant.provider}:${modelKey}:${effortKey}`;
+    const existing = keyToVariants.get(key);
+    if (existing) {
+      existing.push(variant);
+    } else {
+      keyToVariants.set(key, [variant]);
+    }
+  }
+  const duplicates = [...keyToVariants.entries()].filter(([, group]) => group.length > 1);
+  if (duplicates.length === 0) return;
+  const details = duplicates.map(([, group]) => {
+    const variant = group[0];
+    const label = [
+      variant?.provider ?? "unknown",
+      variant?.model ?? "(default)",
+      variant?.modelReasoningEffort ? `effort-${variant.modelReasoningEffort}` : void 0
+    ].filter((part) => typeof part === "string" && part.length > 0).join(":");
+    return `   \u2022 ${label} \u2014 appears ${group.length} times`;
+  }).join("\n");
+  throw new Error(
+    `Duplicate variant specs detected in competition stage
+
+What this means:
+   Competition stages should compare different variants, not the same variant
+   to itself. Duplicates are identified by provider+model+reasoningEffort identity.
+
+Duplicate variants found:
+${details}
+
+How to fix:
+   1. Remove duplicate entries from your competition.variants configuration
+   2. Or change the model or reasoning effort to make variants distinct
+   3. Or use different providers (e.g., claude + codex)
+
+Escape hatch (not recommended):
+   Set competition.allowDuplicateVariantSpecs: true in your stage config
+
+Tip: This guard prevents wasted compute on redundant comparisons.`
+  );
+}
+function resolveCompetitionExecutionIntent(stage) {
+  return resolveProviderExecutionIntentFromStage(stage);
+}
+function getVariantDurationMs(result) {
+  if (typeof result.executionDurationMs === "number" && Number.isFinite(result.executionDurationMs)) {
+    return result.executionDurationMs;
+  }
+  if (typeof result.totalDurationSec === "number" && Number.isFinite(result.totalDurationSec)) {
+    return result.totalDurationSec * 1e3;
+  }
+  return Math.max(0, Math.round((result.duration ?? 0) * 1e3));
+}
+function extractChangedFiles(result) {
+  const statusLines = result.worktreeSummary?.statusLines;
+  if (!Array.isArray(statusLines) || statusLines.length === 0) return void 0;
+  const candidates = statusLines.map((line) => extractChangedFileFromStatusLine(String(line))).filter((v) => Boolean(v));
+  const trackedRoots = result.retainedWorktreePath && candidates.some(isUnderRootToolOutputDir) ? readTrackedToolOutputRootsSync(result.retainedWorktreePath, result.baselineRef || "HEAD") : void 0;
+  const files = candidates.filter((f) => !shouldExcludeFile(f, trackedRoots));
+  return files.length > 0 ? files : void 0;
+}
+function normalizeCoveragePath(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
+}
+function tryGetPct(metric) {
+  if (!metric || typeof metric !== "object") return null;
+  const pct = metric.pct;
+  return typeof pct === "number" && Number.isFinite(pct) ? pct : null;
+}
+function getCoveragePctForEntry(entry) {
+  if (!entry || typeof entry !== "object") return null;
+  const record = entry;
+  return tryGetPct(record.lines) ?? tryGetPct(record.statements) ?? tryGetPct(record.functions) ?? tryGetPct(record.branches) ?? null;
+}
+function getTotalLinesForEntry(entry) {
+  if (!entry || typeof entry !== "object") return null;
+  const record = entry;
+  const lines = record.lines;
+  if (!lines || typeof lines !== "object") return null;
+  const total = lines.total;
+  return typeof total === "number" && Number.isFinite(total) ? total : null;
+}
+async function loadCoverageSummaryJson(worktreePath, summaryPath, options = {}) {
+  try {
+    const resolved = path.join(worktreePath, summaryPath);
+    if (typeof options.minMtimeMs === "number") {
+      const stats = await fs.stat(resolved);
+      if (stats.mtimeMs < options.minMtimeMs) return null;
+    }
+    const raw = await fs.readFile(resolved, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function findCoverageEntry(summary, target) {
+  const normalizedTarget = normalizeCoveragePath(target);
+  const direct = summary[normalizedTarget];
+  if (direct && typeof direct === "object") {
+    return direct;
+  }
+  const candidates = [];
+  for (const [key, value] of Object.entries(summary)) {
+    if (key === "total") continue;
+    if (!value || typeof value !== "object") continue;
+    const normalizedKey = normalizeCoveragePath(key);
+    if (normalizedKey === normalizedTarget || normalizedKey.endsWith(`/${normalizedTarget}`)) {
+      candidates.push({ key, entry: value });
+    }
+  }
+  if (candidates.length === 0) return null;
+  candidates.sort((a, b) => a.key.length - b.key.length);
+  return candidates[0]?.entry ?? null;
+}
+function computeCoverageStatsForTargets(summary, targets) {
+  const byTarget = {};
+  const linesByTarget = {};
+  const missingTargets = [];
+  const pcts = [];
+  const lineCounts = [];
+  for (const target of targets) {
+    if (!summary) {
+      byTarget[target] = null;
+      linesByTarget[target] = null;
+      missingTargets.push(target);
+      continue;
+    }
+    const entry = findCoverageEntry(summary, target);
+    const pct = entry ? getCoveragePctForEntry(entry) : null;
+    const lines = entry ? getTotalLinesForEntry(entry) : null;
+    byTarget[target] = pct;
+    linesByTarget[target] = lines;
+    if (pct === null) {
+      missingTargets.push(target);
+    } else {
+      pcts.push(pct);
+    }
+    if (typeof lines === "number") {
+      lineCounts.push(lines);
+    }
+  }
+  if (pcts.length === 0) {
+    return {
+      byTarget,
+      linesByTarget,
+      avgPct: null,
+      minPct: null,
+      totalLines: null,
+      maxTargetLines: null,
+      missingTargets
+    };
+  }
+  const avgRaw = pcts.reduce((sum, v) => sum + v, 0) / pcts.length;
+  const minRaw = Math.min(...pcts);
+  const round2 = (v) => Math.round(v * 100) / 100;
+  const totalLines = lineCounts.length > 0 ? lineCounts.reduce((sum, v) => sum + v, 0) : null;
+  const maxTargetLines = lineCounts.length > 0 ? Math.max(...lineCounts) : null;
+  return {
+    byTarget,
+    linesByTarget,
+    avgPct: round2(avgRaw),
+    minPct: round2(minRaw),
+    totalLines,
+    maxTargetLines,
+    missingTargets
+  };
+}
+function parseBaselineLinesPctFromPrompt(prompt) {
+  const match = prompt.match(/Baseline:\s*lines\s+(\d+(?:\.\d+)?)%/i);
+  if (!match) return null;
+  const value = Number.parseFloat(match[1] ?? "");
+  return Number.isFinite(value) ? value : null;
+}
+function resolveAutoCoverageMode(params) {
+  const { maxTargetLines, largeFileLineThreshold, baselineAvgPct, threshold, minDeltaPct } = params;
+  if (typeof maxTargetLines === "number" && maxTargetLines > largeFileLineThreshold) {
+    return "delta";
+  }
+  if (typeof threshold === "number" && typeof baselineAvgPct === "number" && threshold - baselineAvgPct > minDeltaPct) {
+    return "delta";
+  }
+  return "absolute";
+}
+function computeExpectedAllowlist(stage) {
+  return collectDeclaredStageTargets(stage);
+}
+function computeCompetitionDrift(candidates, expectedAllowlist, mode) {
+  const allDeliveredFiles = /* @__PURE__ */ new Set();
+  const allViolations = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    if (!candidate.success || !candidate.changedFiles) continue;
+    const changedFiles = filterWorktreeRunSentinelPaths(candidate.changedFiles);
+    for (const file of changedFiles) {
+      allDeliveredFiles.add(file);
+    }
+    const decision = decideStageChangeScope({
+      changedPaths: changedFiles,
+      explicitScope: expectedAllowlist,
+      allowlistMode: mode,
+      mutationOrigin: "provider"
+    });
+    for (const violation of decision.allowlistViolations) {
+      allViolations.add(violation);
+    }
+  }
+  const deliveredFiles = [...allDeliveredFiles];
+  const violations = [...allViolations];
+  const hasDrift = violations.length > 0;
+  const lines = [];
+  lines.push(`Competition stage (${candidates.length} candidates)`);
+  lines.push(`Mode: ${mode}`);
+  lines.push(`Total delivered files: ${deliveredFiles.length}`);
+  lines.push(`Expected allowlist entries: ${expectedAllowlist.length}`);
+  if (hasDrift) {
+    lines.push(`Drift: ${violations.length} file(s) outside allowlist`);
+    for (const v of violations.slice(0, 3)) {
+      lines.push(`  - ${v}`);
+    }
+    if (violations.length > 3) {
+      lines.push(`  ... and ${violations.length - 3} more`);
+    }
+  } else {
+    lines.push("Drift: none");
+  }
+  return {
+    mode,
+    deliveredFiles,
+    expectedFiles: expectedAllowlist,
+    violations,
+    hasDrift,
+    summary: lines.join("\n")
+  };
+}
+var DEFAULT_COHERENCE_THRESHOLD = 0.3;
+function jaccardSimilarity(setA, setB) {
+  if (setA.size === 0 && setB.size === 0) return 1;
+  const intersection = new Set([...setA].filter((x) => setB.has(x)));
+  const union = /* @__PURE__ */ new Set([...setA, ...setB]);
+  return union.size > 0 ? intersection.size / union.size : 0;
+}
+function computeCoherenceMetrics(candidates, threshold = DEFAULT_COHERENCE_THRESHOLD, expectedAllowlist) {
+  const allowlist = (expectedAllowlist ?? []).filter((v) => typeof v === "string" && v.length > 0);
+  const hasAllowlist = allowlist.length > 0;
+  const isAllowlisted = (filePath) => {
+    const normalized = filePath.replace(/\\/g, "/");
+    for (const entry of allowlist) {
+      const rule = entry.replace(/\\/g, "/");
+      if (rule.endsWith("/")) {
+        if (normalized.startsWith(rule)) return true;
+      } else if (normalized === rule) {
+        return true;
+      }
+    }
+    return false;
+  };
+  const filterCandidateFiles = (files) => {
+    if (!files) return void 0;
+    if (!hasAllowlist) return files;
+    const filtered = files.filter(isAllowlisted);
+    return filtered.length > 0 ? filtered : void 0;
+  };
+  const successfulCandidates = candidates.filter(
+    (c) => c.success && filterCandidateFiles(c.changedFiles)?.length
+  );
+  if (successfulCandidates.length < 2) {
+    return {
+      pairwiseSimilarity: {},
+      averageSimilarity: 1,
+      // Single candidate = coherent with itself
+      isCoherent: true,
+      coherenceThreshold: threshold
+    };
+  }
+  const fileSets = /* @__PURE__ */ new Map();
+  for (const [index, candidate] of successfulCandidates.entries()) {
+    const provider = candidate.variant.provider;
+    const model = candidate.variant.model ?? "";
+    const key = `${provider}:${model}:${index}`;
+    fileSets.set(key, new Set(filterCandidateFiles(candidate.changedFiles) || []));
+  }
+  const pairwiseSimilarity = {};
+  const candidateKeys = Array.from(fileSets.keys());
+  let totalSimilarity = 0;
+  let pairCount = 0;
+  for (let i = 0; i < candidateKeys.length; i++) {
+    for (let j = i + 1; j < candidateKeys.length; j++) {
+      const keyA = candidateKeys[i] ?? "";
+      const keyB = candidateKeys[j] ?? "";
+      const setA = fileSets.get(keyA);
+      const setB = fileSets.get(keyB);
+      if (!setA || !setB) continue;
+      const similarity = jaccardSimilarity(setA, setB);
+      const pairKey = `${keyA}|${keyB}`;
+      pairwiseSimilarity[pairKey] = Math.round(similarity * 100) / 100;
+      totalSimilarity += similarity;
+      pairCount++;
+    }
+  }
+  const averageSimilarity = pairCount > 0 ? totalSimilarity / pairCount : 1;
+  const isCoherent = averageSimilarity >= threshold;
+  const allFileSets = Array.from(fileSets.values());
+  const allFiles = new Set(allFileSets.flatMap((s) => [...s]));
+  const commonFiles = [...allFiles].filter((file) => allFileSets.every((set) => set.has(file)));
+  const uniqueFiles = {};
+  for (const [candidateKey, files] of fileSets) {
+    const unique = [...files].filter(
+      (file) => !Array.from(fileSets.entries()).filter(([k]) => k !== candidateKey).some(([, otherSet]) => otherSet.has(file))
+    );
+    if (unique.length > 0) {
+      uniqueFiles[candidateKey] = unique;
+    }
+  }
+  return {
+    pairwiseSimilarity,
+    averageSimilarity: Math.round(averageSimilarity * 100) / 100,
+    isCoherent,
+    coherenceThreshold: threshold,
+    fileOverlap: {
+      commonFiles,
+      uniqueFiles
+    }
+  };
+}
+function resolveCandidateCompletenessFallback(result) {
+  const typed = resolveTypedCompletenessAuthority(result);
+  if (typed.present) {
+    return typed.usable ? typed.score : -1;
+  }
+  return result.completeness;
+}
+function variantResultToCandidate(spec, result) {
+  if (!result) {
+    return {
+      variant: spec,
+      success: false,
+      error: "Variant not found in results",
+      cost: 0,
+      costUnavailableReason: "provider_not_reported",
+      durationMs: 0
+    };
+  }
+  const variantEvaluation = result.judgeEvaluation?.evaluations?.find(
+    (e) => e.variant === result.variant
+  );
+  const aiJudgeScore = variantEvaluation?.qualityScore != null ? Number(variantEvaluation.qualityScore) : void 0;
+  const score = aiJudgeScore ?? result.judgeScore ?? resolveCandidateCompletenessFallback(result);
+  const feedback = generateCandidateFeedback(variantEvaluation, result);
+  const testStatus = result.testStatus;
+  const testsExecuted = result.testsExecuted;
+  const nativeObservedCost = getFiniteNumberAtPath(result, ["result", "totalCostUsd"]) ?? getFiniteNumberAtPath(result, ["result", "total_cost_usd"]) ?? getFiniteNumberAtPath(result, ["result", "totalCost"]) ?? getFiniteNumberAtPath(result, ["totalCostUsd"]);
+  const metricsCost = getFiniteNumberAtPath(result.costMetrics, ["totalCost"]) ?? getFiniteNumberAtPath(result.costMetrics, ["totalCostUsd"]);
+  const metricsUnavailableReason = resolveCostMetricsUnavailableReason(result.costMetrics);
+  let cost;
+  let costUnavailableReason;
+  if (typeof nativeObservedCost === "number") {
+    cost = nativeObservedCost;
+    costUnavailableReason = void 0;
+  } else if (typeof metricsCost === "number" && metricsCost > 0) {
+    cost = metricsCost;
+    costUnavailableReason = void 0;
+  } else if (metricsUnavailableReason !== void 0) {
+    cost = 0;
+    costUnavailableReason = metricsUnavailableReason;
+  } else if (typeof metricsCost === "number") {
+    cost = metricsCost;
+    costUnavailableReason = void 0;
+  } else {
+    cost = 0;
+    costUnavailableReason = "provider_not_reported";
+  }
+  return {
+    variant: spec,
+    success: result.success,
+    error: result.error?.message,
+    ...isProviderInvocationFailure(result) ? { providerFailed: true } : {},
+    score,
+    feedback,
+    cost,
+    costUnavailableReason,
+    durationMs: getVariantDurationMs(result),
+    worktreePath: result.retainedWorktreePath,
+    changedFiles: extractChangedFiles(result),
+    changeTrackingAvailable: resultHasChangeTracking(result),
+    testStatus,
+    testsExecuted,
+    ...repairOutcomeCanSupersedeRawTouchedFailure(result) ? { repairedTestStatus: deriveVariantOutcome(result).verification.testStatus } : {},
+    mergeInvariantValidation: result.mergeInvariantValidation
+  };
+}
+function resolveCompetitionCostAggregate(candidates) {
+  let sum = 0;
+  let firstExplicitReason;
+  let sawPricingUnavailable = false;
+  let sawUnavailable = false;
+  for (const candidate of candidates) {
+    if (candidate.costUnavailableReason !== void 0) {
+      sawUnavailable = true;
+      if (candidate.costUnavailableReason === "pricing_unavailable") {
+        sawPricingUnavailable = true;
+      } else if (firstExplicitReason === void 0) {
+        firstExplicitReason = candidate.costUnavailableReason;
+      }
+      sum = 0;
+      continue;
+    }
+    if (typeof candidate.cost !== "number" || !Number.isFinite(candidate.cost)) {
+      sawUnavailable = true;
+      if (firstExplicitReason === void 0) {
+        firstExplicitReason = "provider_not_reported";
+      }
+      sum = 0;
+      continue;
+    }
+    if (!sawUnavailable) {
+      sum += candidate.cost;
+    }
+  }
+  if (sawUnavailable) {
+    return {
+      cost: 0,
+      costUnavailableReason: sawPricingUnavailable ? "pricing_unavailable" : firstExplicitReason ?? "provider_not_reported"
+    };
+  }
+  return { cost: sum };
+}
+function isJudgeType(value) {
+  return value === "ai" || value === "multi-lens";
+}
+function buildMultiJudgeEvidenceBlock(args) {
+  const synthesisContext = args.judgeResult?.synthesisContext;
+  if (!synthesisContext && !args.matrixRan) {
+    return void 0;
+  }
+  const judgesWithVerdicts = synthesisContext?.judgeResults ? Object.entries(synthesisContext.judgeResults).filter(([, result]) => result !== void 0 && result !== null).map(([judgeId]) => judgeId) : [];
+  return {
+    selectedJudge: synthesisContext?.selectedJudge,
+    judgeRunRequested: args.judgeRunRequested ?? [],
+    judgesWithVerdicts,
+    allJudgesAgree: synthesisContext?.disagreement?.allAgree,
+    matrixAuthority: args.matrixAuthority,
+    matrixRan: args.matrixRan,
+    matrixProfileAgreement: args.matrixProfileAgreement,
+    matrixNonSelectionReasons: args.matrixNonSelectionReasons && args.matrixNonSelectionReasons.length > 0 ? args.matrixNonSelectionReasons : void 0
+  };
+}
+function recordDeterministicTestSignalObservation(candidates, verbose) {
+  const hasVerifiedPassingCandidate = candidates.some(
+    (c) => c.success && c.testsExecuted !== void 0 && c.testStatus === "passed"
+  );
+  if (!hasVerifiedPassingCandidate) return;
+  for (const candidate of candidates) {
+    if (!candidate.success) continue;
+    if (!candidate.testsExecuted) continue;
+    const status = candidate.testStatus ?? "not_run";
+    if (status !== "failed" && status !== "error" && status !== "timeout") continue;
+    const note = `Verified failing test observation recorded (testStatus=${status}).`;
+    candidate.feedback = candidate.feedback ? `${note}
+
+${candidate.feedback}` : note;
+    if (verbose) {
+      const id = formatCompetitionCandidateVariantDisplay(candidate);
+      console.log(
+        chalk.yellow(`   Test observation: ${id} retained score ${candidate.score ?? 0}`)
+      );
+    }
+  }
+}
+function variantResultDiagnosticId(result) {
+  const provider = result.provider ?? "unknown";
+  const model = result.model ?? "";
+  const variant = result.variant ? ` (${result.variant})` : "";
+  return `${provider}:${model}${variant}`;
+}
+function buildWinnerInfoFromJudgeVerdict(candidates, judgedWinner, judgeVisibleCandidates) {
+  const rankedPool = judgeVisibleCandidates && judgeVisibleCandidates.length > 0 ? judgeVisibleCandidates : candidates.filter((c) => c.success);
+  if (rankedPool.length === 0) {
+    return {
+      winner: null,
+      noWinnerReason: "all-failed",
+      wasTie: false,
+      rankings: []
+    };
+  }
+  const ranked = [...rankedPool].sort((a, b) => {
+    const scoreA = Number(a.score ?? 0);
+    const scoreB = Number(b.score ?? 0);
+    if (scoreB !== scoreA) return scoreB - scoreA;
+    return variantIdForSpec(a.variant).localeCompare(variantIdForSpec(b.variant));
+  });
+  const rankings = ranked.map((c, i) => ({
+    variant: c.variant,
+    score: c.score ?? 0,
+    rank: i + 1
+  }));
+  const topScore = Number(ranked[0]?.score ?? 0);
+  const tiedAtTop = ranked.filter((c) => Number(c.score ?? 0) === topScore);
+  const wasTie = tiedAtTop.length > 1;
+  if (!judgedWinner) {
+    return {
+      winner: null,
+      wasTie,
+      rankings
+    };
+  }
+  const winner = findCandidateForVariantResult(candidates, judgedWinner);
+  if (!winner) {
+    return {
+      winner: null,
+      wasTie,
+      rankings,
+      noWinnerReason: "judge-error",
+      noWinnerDiagnostic: `AI judge selected an unmatched winner (${variantResultDiagnosticId(
+        judgedWinner
+      )}); judge-visible candidates: ${rankedPool.map((candidate) => variantIdForSpec(candidate.variant)).join(", ")}`
+    };
+  }
+  return {
+    winner,
+    wasTie,
+    rankings
+  };
+}
+function attachGateObservationsToVariantResult(result, candidate) {
+  const candidateFindings = candidate.verification?.findings ?? [];
+  const gateError = candidate.success === false ? candidate.error : void 0;
+  if (candidateFindings.length === 0 && !gateError) {
+    return result;
+  }
+  const existingFindings = result.verification?.findings ?? [];
+  const mergedFindings = [...existingFindings];
+  for (const finding of candidateFindings) {
+    const mapped = toCoreVerificationFinding(finding);
+    const alreadyPresent = mergedFindings.some(
+      (existing) => existing.kind === mapped.kind && existing.command === mapped.command && existing.exitCode === mapped.exitCode
+    );
+    if (!alreadyPresent) {
+      mergedFindings.push(mapped);
+    }
+  }
+  if (gateError && mergedFindings.length === existingFindings.length) {
+    mergedFindings.push({
+      kind: "other",
+      command: "candidate-gate",
+      exitCode: 1,
+      severity: "error",
+      outputTail: gateError
+    });
+  }
+  const verificationPassed = candidate.verification?.passed === false ? false : gateError ? false : result.verification?.passed ?? true;
+  result.verification = {
+    ...result.verification ?? {},
+    passed: verificationPassed,
+    findings: mergedFindings
+  };
+  return result;
+}
+function buildJudgeVisibleVariantResults(finishedCandidates, basicVariants) {
+  const results = [];
+  for (const candidate of finishedCandidates) {
+    const matching = matchVariantResult(candidate.variant, basicVariants);
+    if (!matching) continue;
+    results.push(attachGateObservationsToVariantResult(matching, candidate));
+  }
+  return results;
+}
+function determineWinner(candidates, config, expectedAllowlist) {
+  const SCORE_COLLISION_DECIMALS = 6;
+  const SCORE_COLLISION_MULTIPLIER = 10 ** SCORE_COLLISION_DECIMALS;
+  const quantizeScore = (score) => {
+    if (!Number.isFinite(score)) return 0;
+    return Math.round(score * SCORE_COLLISION_MULTIPLIER) / SCORE_COLLISION_MULTIPLIER;
+  };
+  const variantIdFor = variantIdForSpec;
+  const buildCollisionReport = (args) => {
+    const tiedAtTop2 = [...args.tiedAtTop].map((c) => {
+      const raw = Number(c.score ?? 0);
+      const q = quantizeScore(raw);
+      return { candidate: c, scoreRaw: raw, scoreQuantized: q, id: variantIdFor(c.variant) };
+    }).sort((a, b) => a.id.localeCompare(b.id)).map((x) => ({
+      variant: x.candidate.variant,
+      scoreRaw: x.scoreRaw,
+      scoreQuantized: x.scoreQuantized
+    }));
+    const otherCollisionGroups2 = [...args.otherCollisionGroups].sort((a, b) => b.scoreQuantized - a.scoreQuantized).map((group) => ({
+      scoreQuantized: group.scoreQuantized,
+      entries: [...group.entries].map((e) => ({ ...e, id: variantIdFor(e.variant) })).sort((a, b) => a.id.localeCompare(b.id)).map((e) => ({ variant: e.variant, scoreRaw: e.scoreRaw }))
+    }));
+    return {
+      precisionDecimals: SCORE_COLLISION_DECIMALS,
+      quantization: "round",
+      topScoreRaw: args.topScoreRaw,
+      topScoreQuantized: args.topScoreQuantized,
+      successfulCandidateCount: args.successfulCount,
+      collisionGroupCount: args.collisionGroupsAll.length,
+      collisionPairCount: args.collisionGroupsAll.reduce(
+        (sum, g) => sum + g.entries.length * (g.entries.length - 1) / 2,
+        0
+      ),
+      tiedAtTopPairCount: args.tiedAtTop.length * (args.tiedAtTop.length - 1) / 2,
+      tiedAtTop: tiedAtTop2,
+      otherCollisionGroups: otherCollisionGroups2,
+      applied: args.applied
+    };
+  };
+  const computeCollisionGroups = (rankedSuccessful) => {
+    const groups = /* @__PURE__ */ new Map();
+    for (const candidate of rankedSuccessful) {
+      const scoreRaw = Number(candidate.score ?? 0);
+      const scoreQuantized = quantizeScore(scoreRaw);
+      const existing = groups.get(scoreQuantized);
+      if (existing) {
+        existing.push({ variant: candidate.variant, scoreRaw });
+      } else {
+        groups.set(scoreQuantized, [{ variant: candidate.variant, scoreRaw }]);
+      }
+    }
+    const out = [];
+    for (const [scoreQuantized, entries] of groups.entries()) {
+      if (entries.length < 2) continue;
+      out.push({ scoreQuantized, entries });
+    }
+    return out;
+  };
+  const successfulCandidates = candidates.filter((c) => c.success);
+  const threshold = config.judgeConfig?.threshold ?? 0;
+  const allowBelowThresholdWinner = config.judgeConfig?.allowBelowThresholdWinner ?? true;
+  if (successfulCandidates.length === 0) {
+    return {
+      winner: null,
+      noWinnerReason: "all-failed",
+      wasTie: false,
+      rankings: []
+    };
+  }
+  const cleanCandidates = successfulCandidates.filter(
+    (c) => !c.verification || c.verification.passed
+  );
+  const candidatesWithFindings = successfulCandidates.filter(
+    (c) => c.verification && !c.verification.passed
+  );
+  const candidatesToRank = cleanCandidates.length > 0 ? cleanCandidates : successfulCandidates;
+  const ranked = [...candidatesToRank].sort((a, b) => {
+    const scoreA = Number(a.score ?? 0);
+    const scoreB = Number(b.score ?? 0);
+    const qa = quantizeScore(scoreA);
+    const qb = quantizeScore(scoreB);
+    if (qb !== qa) return qb - qa;
+    return variantIdFor(a.variant).localeCompare(variantIdFor(b.variant));
+  });
+  const rankings = ranked.map((c, i) => ({
+    variant: c.variant,
+    score: c.score ?? 0,
+    rank: i + 1
+  }));
+  const topScore = Number(ranked[0]?.score ?? 0);
+  const topScoreQuantized = quantizeScore(topScore);
+  const tiedAtTop = ranked.filter((c) => quantizeScore(Number(c.score ?? 0)) === topScoreQuantized);
+  const wasTie = tiedAtTop.length > 1;
+  const collisionGroups = computeCollisionGroups(ranked);
+  const otherCollisionGroups = collisionGroups.filter((g) => g.scoreQuantized !== topScoreQuantized).slice(0, 10);
+  const scoreCollisionReportBase = wasTie || otherCollisionGroups.length > 0 ? {
+    ranked,
+    successfulCount: candidatesToRank.length,
+    collisionGroupsAll: collisionGroups,
+    topScoreRaw: topScore,
+    topScoreQuantized,
+    tiedAtTop,
+    otherCollisionGroups
+  } : null;
+  if (wasTie) {
+    if (config.applyWinner) {
+      const tieBreakerConfig = config.tieBreaker ?? (config.candidateGate?.coverage ? { mode: "prefer-low-drift-then-diff" } : { mode: "prefer-first-ranked" });
+      let winner2 = null;
+      let resolvedBy = "rank";
+      const getCandidateChangedFileCount = (candidate) => Array.isArray(candidate.changedFiles) ? candidate.changedFiles.length : 0;
+      const getCandidateDriftViolations = (candidate) => {
+        if (!Array.isArray(candidate.changedFiles) || candidate.changedFiles.length === 0) return 0;
+        if (!Array.isArray(expectedAllowlist) || expectedAllowlist.length === 0) return 0;
+        return findAllowlistViolations(candidate.changedFiles, expectedAllowlist).length;
+      };
+      if (tieBreakerConfig.mode === "inconclusive") {
+        const aiJudgeDisabled = config.judgeConfig?.disableAiJudge === true;
+        if (aiJudgeDisabled) {
+          const scoreCollisionReport2 = scoreCollisionReportBase && scoreCollisionReportBase.tiedAtTop.length > 1 ? buildCollisionReport({
+            ...scoreCollisionReportBase,
+            applied: {
+              applyWinner: Boolean(config.applyWinner),
+              wasTie: true,
+              noWinnerReason: "tie",
+              tieBreakerMode: tieBreakerConfig.mode,
+              resolvedBy: void 0,
+              winnerVariant: void 0
+            }
+          }) : void 0;
+          return {
+            winner: null,
+            noWinnerReason: "tie",
+            wasTie: true,
+            rankings,
+            scoreCollisionReport: scoreCollisionReport2
+          };
+        }
+        winner2 = tiedAtTop[0] ?? null;
+        resolvedBy = "rank";
+      } else if (tieBreakerConfig.mode === "prefer-first-ranked") {
+        winner2 = tiedAtTop[0] ?? null;
+      } else if (tieBreakerConfig.mode === "prefer-low-drift") {
+        winner2 = [...tiedAtTop].sort((a, b) => {
+          const driftDelta = getCandidateDriftViolations(a) - getCandidateDriftViolations(b);
+          if (driftDelta !== 0) return driftDelta;
+          return variantIdFor(a.variant).localeCompare(variantIdFor(b.variant));
+        })[0] ?? null;
+        resolvedBy = "drift";
+      } else if (tieBreakerConfig.mode === "prefer-smaller-diff") {
+        winner2 = [...tiedAtTop].sort((a, b) => {
+          const diffDelta = getCandidateChangedFileCount(a) - getCandidateChangedFileCount(b);
+          if (diffDelta !== 0) return diffDelta;
+          return variantIdFor(a.variant).localeCompare(variantIdFor(b.variant));
+        })[0] ?? null;
+        resolvedBy = "diff";
+      } else if (tieBreakerConfig.mode === "prefer-low-drift-then-diff") {
+        winner2 = [...tiedAtTop].sort((a, b) => {
+          const driftDelta = getCandidateDriftViolations(a) - getCandidateDriftViolations(b);
+          if (driftDelta !== 0) return driftDelta;
+          const diffDelta = getCandidateChangedFileCount(a) - getCandidateChangedFileCount(b);
+          if (diffDelta !== 0) return diffDelta;
+          return variantIdFor(a.variant).localeCompare(variantIdFor(b.variant));
+        })[0] ?? null;
+        if (winner2) {
+          const winnerDrift = getCandidateDriftViolations(winner2);
+          const allSameDrift = tiedAtTop.every(
+            (c) => getCandidateDriftViolations(c) === winnerDrift
+          );
+          if (!allSameDrift) {
+            resolvedBy = "drift";
+          } else {
+            const winnerDiff = getCandidateChangedFileCount(winner2);
+            const allSameDiff = tiedAtTop.every(
+              (c) => getCandidateChangedFileCount(c) === winnerDiff
+            );
+            resolvedBy = allSameDiff ? "rank" : "diff";
+          }
+        } else {
+          resolvedBy = "drift";
+        }
+      } else {
+        winner2 = tiedAtTop[0] ?? null;
+      }
+      if (!winner2) winner2 = ranked[0] ?? null;
+      if (winner2) {
+        const scoreCollisionReport2 = scoreCollisionReportBase && scoreCollisionReportBase.tiedAtTop.length > 1 ? buildCollisionReport({
+          ...scoreCollisionReportBase,
+          applied: {
+            applyWinner: true,
+            wasTie: true,
+            noWinnerReason: void 0,
+            tieBreakerMode: tieBreakerConfig.mode,
+            resolvedBy,
+            winnerVariant: winner2.variant
+          }
+        }) : void 0;
+        return {
+          winner: winner2,
+          wasTie: true,
+          // Still record that there was a tie
+          rankings,
+          tieBreaker: {
+            mode: tieBreakerConfig.mode,
+            resolvedBy,
+            winnerDriftViolations: getCandidateDriftViolations(winner2),
+            winnerChangedFiles: getCandidateChangedFileCount(winner2),
+            tieScore: topScore,
+            tieScoreRounded: topScoreQuantized,
+            tieScoreRoundedDecimals: SCORE_COLLISION_DECIMALS,
+            tiedCount: tiedAtTop.length
+          },
+          scoreCollisionReport: scoreCollisionReport2
+        };
+      }
+    }
+    const scoreCollisionReport = scoreCollisionReportBase && scoreCollisionReportBase.tiedAtTop.length > 1 ? buildCollisionReport({
+      ...scoreCollisionReportBase,
+      applied: {
+        applyWinner: Boolean(config.applyWinner),
+        wasTie: true,
+        noWinnerReason: "tie",
+        tieBreakerMode: config.tieBreaker?.mode,
+        resolvedBy: void 0,
+        winnerVariant: void 0
+      }
+    }) : void 0;
+    return {
+      winner: null,
+      noWinnerReason: "tie",
+      wasTie: true,
+      rankings,
+      scoreCollisionReport
+    };
+  }
+  if (topScore < threshold) {
+    const verificationPolicy = config.verificationPolicy ?? "findings";
+    if (verificationPolicy === "findings") {
+      const bestRepairable = candidatesWithFindings.map((c) => ({
+        candidate: c,
+        effectiveScore: c.scoreBeforeTestSignal ?? c.score ?? 0
+      })).filter((x) => x.effectiveScore >= threshold).sort((a, b) => b.effectiveScore - a.effectiveScore)[0]?.candidate;
+      if (bestRepairable) {
+        const restoredScore = bestRepairable.scoreBeforeTestSignal ?? bestRepairable.score;
+        return {
+          winner: {
+            ...bestRepairable,
+            score: restoredScore,
+            feedback: bestRepairable.feedback ? `Selected for repair (tests recorded findings; observed score: ${restoredScore}).
+
+${bestRepairable.feedback}` : `Selected for repair (tests recorded findings; observed score: ${restoredScore}).`
+          },
+          wasTie: false,
+          rankings
+        };
+      }
+    }
+    if (allowBelowThresholdWinner) {
+      const winner2 = ranked[0] ?? null;
+      if (winner2) {
+        return {
+          winner: winner2,
+          wasTie: false,
+          rankings,
+          belowThresholdWinner: {
+            threshold,
+            winnerScore: topScore
+          },
+          scoreCollisionReport: scoreCollisionReportBase && (scoreCollisionReportBase.tiedAtTop.length > 1 || scoreCollisionReportBase.otherCollisionGroups.length > 0) ? buildCollisionReport({
+            ...scoreCollisionReportBase,
+            applied: {
+              applyWinner: Boolean(config.applyWinner),
+              wasTie: false,
+              noWinnerReason: void 0,
+              tieBreakerMode: config.tieBreaker?.mode,
+              resolvedBy: void 0,
+              winnerVariant: winner2.variant
+            }
+          }) : void 0
+        };
+      }
+    }
+    return {
+      winner: null,
+      noWinnerReason: "below-threshold",
+      wasTie: false,
+      rankings,
+      scoreCollisionReport: scoreCollisionReportBase && (scoreCollisionReportBase.tiedAtTop.length > 1 || scoreCollisionReportBase.otherCollisionGroups.length > 0) ? buildCollisionReport({
+        ...scoreCollisionReportBase,
+        applied: {
+          applyWinner: Boolean(config.applyWinner),
+          wasTie: false,
+          noWinnerReason: "below-threshold",
+          tieBreakerMode: config.tieBreaker?.mode,
+          resolvedBy: void 0,
+          winnerVariant: void 0
+        }
+      }) : void 0
+    };
+  }
+  const winner = ranked[0] ?? null;
+  return {
+    winner,
+    wasTie: false,
+    rankings,
+    scoreCollisionReport: scoreCollisionReportBase && (scoreCollisionReportBase.tiedAtTop.length > 1 || scoreCollisionReportBase.otherCollisionGroups.length > 0) ? buildCollisionReport({
+      ...scoreCollisionReportBase,
+      applied: {
+        applyWinner: Boolean(config.applyWinner),
+        wasTie: false,
+        noWinnerReason: void 0,
+        tieBreakerMode: config.tieBreaker?.mode,
+        resolvedBy: void 0,
+        winnerVariant: winner?.variant
+      }
+    }) : void 0
+  };
+}
+var __internalDetermineWinner = determineWinner;
+var __internalRecordDeterministicTestSignalObservation = recordDeterministicTestSignalObservation;
+var __internalExtractChangedFilesFromResult = extractChangedFilesFromResult;
+var __internalGetVariantTelemetryStatePath = getVariantTelemetryStatePath;
+var __internalHydrateCandidateCostsFromTelemetry = hydrateCandidateCostsFromTelemetry;
+var __internalVariantResultToCandidate = variantResultToCandidate;
+var __internalMatchVariantResult = matchVariantResult;
+var __internalCandidateMatchesVariantResult = candidateMatchesVariantResult;
+var __internalResolveCompetitionCostAggregate = resolveCompetitionCostAggregate;
+function synthesizeDeterministicRationalePacket(candidates, winnerInfo, config) {
+  const { winner, wasTie, noWinnerReason, tieBreaker, belowThresholdWinner } = winnerInfo;
+  const buildVariantId = candidateScoreId;
+  const candidateToVariantResult = (candidate) => ({
+    variant: buildVariantId(candidate),
+    success: candidate.success,
+    testStatus: candidate.testStatus,
+    testsExecuted: candidate.testsExecuted ? {
+      scope: candidate.testsExecuted.scope ?? "touched",
+      filesTested: candidate.testsExecuted.filesTested ?? [],
+      exitCode: candidate.testsExecuted.exitCode,
+      durationMs: candidate.testsExecuted.durationMs
+    } : void 0,
+    emptyChanges: !candidate.changedFiles?.length,
+    gitMetrics: candidate.changedFiles ? { filesChanged: candidate.changedFiles.length, linesAdded: 0, linesDeleted: 0 } : void 0,
+    worktreeSummary: candidate.changedFiles ? {
+      filesChanged: candidate.changedFiles.length,
+      insertions: 0,
+      deletions: 0,
+      statusLines: candidate.changedFiles.map((f) => `M  ${f}`)
+    } : void 0
+  });
+  const effectiveWinner = winner;
+  const winnerId = effectiveWinner ? buildVariantId(effectiveWinner) : "none";
+  const scores = {};
+  for (const candidate of candidates) {
+    const variantId = buildVariantId(candidate);
+    scores[variantId] = candidate.score ?? 0;
+  }
+  let unverifiedNegativeClaimCount = 0;
+  const scoreBreakdown = {};
+  for (const candidate of candidates) {
+    const variantId = buildVariantId(candidate);
+    const finalScore = candidate.score ?? 0;
+    const subscores = {};
+    const penalties = {};
+    if (typeof candidate.score === "number") {
+      subscores.delivery = candidate.score;
+    }
+    const deductions = [];
+    if (candidate.testStatus === "failed" || candidate.testStatus === "error") {
+      const testPenalty = candidate.scoreBeforeTestSignal ? candidate.scoreBeforeTestSignal - (candidate.score ?? 0) : 10;
+      penalties.testFailure = testPenalty;
+      const testEvidence = [];
+      testEvidence.push({
+        type: "metric",
+        value: `testStatus: ${candidate.testStatus}`,
+        context: "Test execution result"
+      });
+      if (candidate.testsExecuted?.exitCode !== void 0) {
+        testEvidence.push({
+          type: "metric",
+          value: `exit code: ${candidate.testsExecuted.exitCode}`,
+          context: "Test runner exit code"
+        });
+      }
+      deductions.push({
+        code: "test_failure",
+        delta: -testPenalty,
+        evidence: testEvidence,
+        reason: "Tests failed during verification"
+      });
+    }
+    if (!candidate.changedFiles?.length && candidate.success) {
+      deductions.push({
+        code: "empty_changes",
+        delta: -50,
+        evidence: [
+          {
+            type: "metric",
+            value: "0 files changed",
+            context: "Git status shows no changes"
+          }
+        ],
+        reason: "No code changes detected"
+      });
+    }
+    if (Array.isArray(candidate.changedFiles) && candidate.changedFiles.length > 10) {
+      const excessPenalty = Math.min(10, (candidate.changedFiles.length - 10) * 2);
+      penalties.other = excessPenalty;
+      deductions.push({
+        code: "off_target_files",
+        delta: -excessPenalty,
+        evidence: [
+          {
+            type: "metric",
+            value: `${candidate.changedFiles.length} files changed`,
+            context: "Excessive file changes may indicate scope creep"
+          }
+        ],
+        reason: "Modified more than 10 files"
+      });
+    }
+    const weights = {
+      delivery: 1
+      // Deterministic mode uses completeness as sole factor
+    };
+    const testStatus = candidate.testStatus;
+    const testsExecuted = candidate.testsExecuted;
+    scoreBreakdown[variantId] = {
+      finalScore,
+      subscores,
+      weights,
+      penalties: Object.keys(penalties).length > 0 ? penalties : void 0,
+      aggregationMethod: "weighted_average",
+      // Default for deterministic scoring
+      // P2: Include floor (harmonic mean floor = 18 in Judge v2.2)
+      floorApplied: 18,
+      // P2b: Structured test status (first-class signal)
+      ...testStatus && {
+        testSignal: {
+          status: testStatus,
+          scope: testsExecuted?.scope,
+          exitCode: testsExecuted?.exitCode,
+          durationMs: testsExecuted?.durationMs,
+          penaltyApplied: testStatus === "failed" || testStatus === "error" ? (penalties.testFailure ?? 0) > 0 : false
+        }
+      },
+      // Include deduction trace with evidence (v0.5.0)
+      deductions: deductions.length > 0 ? deductions : void 0
+    };
+  }
+  const highestScoringCandidate = candidates.filter((candidate) => candidate.success && typeof candidate.score === "number").sort((a, b) => {
+    const scoreDelta = Number(b.score ?? 0) - Number(a.score ?? 0);
+    if (scoreDelta !== 0) return scoreDelta;
+    return buildVariantId(a).localeCompare(buildVariantId(b));
+  })[0];
+  const highestScoringCandidateId = highestScoringCandidate ? buildVariantId(highestScoringCandidate) : void 0;
+  const highestScore = highestScoringCandidate?.score ?? 0;
+  const winnerScore = effectiveWinner?.score ?? 0;
+  const winnerHasHighestDeterministicScore = Boolean(effectiveWinner) && (!highestScoringCandidate || highestScoringCandidateId === winnerId || Number(winnerScore) >= Number(highestScore));
+  const candidateAnalysis = candidates.map((candidate) => {
+    const variantId = buildVariantId(candidate);
+    const isWinner = effectiveWinner && buildVariantId(effectiveWinner) === variantId;
+    const strengths = [];
+    const weaknesses = [];
+    const missedRequirements = [];
+    const riskyAreas = [];
+    if (candidate.success) {
+      strengths.push("Execution succeeded");
+      if (typeof candidate.score === "number" && candidate.score > 80) {
+        strengths.push(`High score: ${candidate.score}`);
+      }
+      if (candidate.testsExecuted && candidate.testStatus) {
+        const scope = candidate.testsExecuted.scope ?? "unknown";
+        if (candidate.testStatus === "passed") {
+          strengths.push(`Tests passed (${scope})`);
+        } else if (candidate.testStatus !== "not_run") {
+          weaknesses.push(`Tests ${candidate.testStatus} (${scope})`);
+        }
+      }
+      if (Array.isArray(candidate.changedFiles) && candidate.changedFiles.length > 0) {
+        strengths.push(`Modified ${candidate.changedFiles.length} file(s)`);
+      }
+    } else {
+      weaknesses.push("Execution failed");
+      if (candidate.error) {
+        weaknesses.push(`Error: ${candidate.error}`);
+      }
+    }
+    if (!isWinner && candidate.success) {
+      const candidateScore = candidate.score ?? 0;
+      if (effectiveWinner && typeof candidate.score === "number") {
+        if (candidateScore > winnerScore) {
+          weaknesses.push(
+            `Not selected despite higher deterministic score (${candidateScore} vs selected ${winnerScore})`
+          );
+        } else if (candidateScore === winnerScore) {
+          weaknesses.push("Final tie-breaker selected another candidate");
+        } else {
+          weaknesses.push("Lower score than winner");
+        }
+      } else {
+        weaknesses.push("Did not win final selection");
+      }
+    }
+    const variantForEvidence = candidateToVariantResult(candidate);
+    const weaknessEvidence = {
+      weaknesses: weaknesses.map((weakness, index) => {
+        const isNegative = isNegativeClaim(weakness);
+        const anchors = isNegative ? extractEvidenceAnchors(weakness, variantForEvidence) : [];
+        const verified = !isNegative || anchors.length > 0;
+        if (isNegative && !verified) {
+          unverifiedNegativeClaimCount++;
+        }
+        return {
+          index,
+          anchors: anchors.map((a) => ({
+            type: a.type,
+            value: a.value,
+            context: a.context
+          })),
+          verified
+        };
+      })
+    };
+    return {
+      variantId,
+      strengths,
+      weaknesses,
+      missedRequirements,
+      riskyAreas,
+      evidence: weaknessEvidence.weaknesses?.length ? weaknessEvidence : void 0
+    };
+  });
+  let primaryReason = "Winner selected by deterministic scoring";
+  const keyFactors = [];
+  const selectionEvidence = [];
+  if (noWinnerReason) {
+    const reasons = {
+      "all-failed": "All variants failed execution",
+      tie: "Tie between top variants",
+      "below-threshold": `All scores below threshold (${config.judgeConfig?.threshold ?? 0})`,
+      "judge-error": "Judge evaluation failed",
+      incomparable: "Candidates touched disjoint files (low coherence)"
+    };
+    primaryReason = reasons[noWinnerReason] ?? noWinnerReason;
+  } else if (wasTie && tieBreaker) {
+    primaryReason = `Tie resolved by ${tieBreaker.mode} tiebreaker`;
+    keyFactors.push(`Tiebreaker mode: ${tieBreaker.mode}`);
+    if (tieBreaker.resolvedBy) {
+      keyFactors.push(`Resolved by: ${tieBreaker.resolvedBy}`);
+    }
+  } else if (winner) {
+    primaryReason = winnerHasHighestDeterministicScore ? "Highest deterministic score" : "Final winner selected by judge or selection policy despite lower deterministic score";
+    keyFactors.push(`Score: ${winner.score ?? 0}`);
+    if (!winnerHasHighestDeterministicScore && highestScoringCandidateId) {
+      keyFactors.push(`Top deterministic score: ${highestScoringCandidateId} (${highestScore})`);
+      keyFactors.push(`Selected winner score: ${winnerId} (${winnerScore})`);
+    }
+    selectionEvidence.push({
+      type: "metric",
+      value: `score: ${winner.score ?? 0}`,
+      context: "Winner deterministic score"
+    });
+    if (winner.changedFiles?.length) {
+      selectionEvidence.push({
+        type: "metric",
+        value: `${winner.changedFiles.length} files changed`,
+        context: "Winner modified files"
+      });
+    }
+    if (belowThresholdWinner) {
+      keyFactors.push(
+        `Below threshold: ${belowThresholdWinner.winnerScore} < ${belowThresholdWinner.threshold}`
+      );
+    }
+    if (winner.testsExecuted && winner.testStatus === "passed") {
+      keyFactors.push("Verified passing tests");
+      selectionEvidence.push({
+        type: "metric",
+        value: "testStatus: passed",
+        context: `Tests verified (${winner.testsExecuted.scope ?? "unknown"} scope)`
+      });
+    }
+    if (winner.feedback) {
+      keyFactors.push("Has feedback from deterministic evaluation");
+    }
+  }
+  const rejectionReasons = {};
+  const rejectionReasonsEvidence = {};
+  for (const candidate of candidates) {
+    const variantId = buildVariantId(candidate);
+    if (effectiveWinner && buildVariantId(effectiveWinner) === variantId) continue;
+    let reason;
+    if (!candidate.success) {
+      reason = candidate.error ?? "Execution failed";
+    } else if (candidate.testsExecuted && candidate.testStatus && candidate.testStatus !== "passed") {
+      reason = `Verified failing tests (testStatus=${candidate.testStatus})`;
+    } else if (typeof candidate.score === "number" && typeof effectiveWinner?.score === "number") {
+      if (candidate.score > effectiveWinner.score) {
+        reason = `Not selected despite higher deterministic score (${candidate.score} vs selected ${effectiveWinner.score})`;
+      } else if (candidate.score === effectiveWinner.score) {
+        reason = `Final tie-breaker selected another candidate (${candidate.score} vs selected ${effectiveWinner.score})`;
+      } else {
+        reason = `Lower score (${candidate.score} vs ${effectiveWinner.score})`;
+      }
+    } else {
+      reason = "Did not win deterministic selection";
+    }
+    rejectionReasons[variantId] = reason;
+    if (isNegativeClaim(reason)) {
+      const variantForEvidence = candidateToVariantResult(candidate);
+      const anchors = extractEvidenceAnchors(reason, variantForEvidence);
+      const verified = anchors.length > 0;
+      rejectionReasonsEvidence[variantId] = {
+        anchors: anchors.map((a) => ({
+          type: a.type,
+          value: a.value,
+          context: a.context
+        })),
+        verified
+      };
+      if (!verified) {
+        unverifiedNegativeClaimCount++;
+      }
+    }
+  }
+  const suggestedImprovements = [];
+  const failedCount = candidates.filter((c) => !c.success).length;
+  if (failedCount > 0) {
+    suggestedImprovements.push(`${failedCount} variant(s) failed execution - investigate errors`);
+  }
+  if (wasTie) {
+    suggestedImprovements.push("Consider refining task requirements to reduce ties");
+  }
+  let baseConfidence = noWinnerReason ? 0 : wasTie ? 60 : 100;
+  if (unverifiedNegativeClaimCount > 0) {
+    const penalty = Math.min(0.25, unverifiedNegativeClaimCount * 0.05);
+    baseConfidence = Math.max(0, baseConfidence * (1 - penalty));
+  }
+  return {
+    winnerId,
+    scores,
+    scoreBreakdown,
+    // P1 Fix: Include detailed score breakdown with deduction traces
+    candidateAnalysis,
+    selectionRationale: {
+      primary: primaryReason,
+      keyFactors,
+      confidence: baseConfidence,
+      evidence: selectionEvidence.length > 0 ? selectionEvidence : void 0
+    },
+    rejectionReasons,
+    rejectionReasonsEvidence: Object.keys(rejectionReasonsEvidence).length > 0 ? rejectionReasonsEvidence : void 0,
+    suggestedImprovements,
+    unverifiedNegativeClaimCount: unverifiedNegativeClaimCount > 0 ? unverifiedNegativeClaimCount : void 0
+  };
+}
+function buildCompetitionBundle(taskId, candidates, basicResult) {
+  const lines = [];
+  lines.push("# Competition Bundle");
+  lines.push("");
+  lines.push(`Task ID: ${taskId}`);
+  lines.push("");
+  for (const candidate of candidates) {
+    const provider = candidate.variant.provider;
+    const model = candidate.variant.model;
+    const header = [provider, model].filter(Boolean).join(" / ");
+    const result = matchVariantResult(candidate.variant, basicResult.variants);
+    lines.push(`## ${header || provider}`);
+    lines.push("");
+    lines.push(`- Success: ${candidate.success ? "yes" : "no"}`);
+    lines.push(`- Score: ${candidate.score ?? 0}`);
+    lines.push(`- Cost: $${candidate.cost.toFixed(4)}`);
+    lines.push(`- Duration: ${(candidate.durationMs / 1e3).toFixed(1)}s`);
+    if (candidate.error) {
+      lines.push(`- Error: ${candidate.error}`);
+    }
+    const diff = result?.worktreeDiff;
+    if (typeof diff === "string" && diff.trim().length > 0) {
+      lines.push("");
+      lines.push("```diff");
+      lines.push(diff.trimEnd());
+      lines.push("```");
+    } else {
+      lines.push("");
+      lines.push("_No diff captured._");
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function executeCompetitionStage(ctx) {
+  const { stage, artifactStore, options } = ctx;
+  const securityBoundary = ctx.securityBoundary ?? createSecurityBoundary(artifactStore.getWorkflowId());
+  const startTime = Date.now();
+  const config = stage.competition;
+  if (!config || !config.variants || config.variants.length === 0) {
+    throw new Error(`Stage '${stage.id}' is type=competition but has no variants configured`);
+  }
+  if (options.verbose) {
+    console.log(chalk.blue(`
+Competition Stage: ${stage.id}`));
+    console.log(chalk.gray(`   Variants: ${config.variants.length}`));
+    console.log(chalk.gray(`   Providers: ${config.variants.map((v) => v.provider).join(", ")}`));
+  }
+  let resolvedPrompt = stage.prompt ?? "";
+  try {
+    resolvedPrompt = await resolvePromptArtifacts(
+      stage.prompt ?? "",
+      stage.inputs,
+      artifactStore,
+      stage.id,
+      securityBoundary
+    );
+  } catch (error) {
+    if (error instanceof ArtifactNotFoundError) {
+      const result = {
+        stageId: stage.id,
+        stageType: "competition",
+        validationPassed: false,
+        cost: 0,
+        candidates: [],
+        winner: null,
+        summary: `Failed to resolve input artifacts: ${error.message}`,
+        durationMs: Date.now() - startTime
+      };
+      return result;
+    }
+    throw error;
+  }
+  if (options.verbose) {
+    console.log(chalk.gray(`   Prompt length: ${resolvedPrompt.length} chars`));
+  }
+  const effectiveMode = options.allowlistMode ?? "warn";
+  const expectedAllowlistForSkip = computeExpectedAllowlist(stage);
+  const requireChangesDemandsEdits = stage.validation?.requireChanges === true && stage.allowEmptyResults !== true;
+  if (!requireChangesDemandsEdits && stageHasDeterministicChecks(stage) && typeof options.workerCwd === "string" && options.workerCwd.length > 0) {
+    try {
+      const skipProof = await evaluateStageCompletionProof({
+        stage,
+        worktreePath: options.workerCwd,
+        stdout: "",
+        attemptChangedFiles: [],
+        allowlist: expectedAllowlistForSkip,
+        stageId: stage.id
+      });
+      const alreadySatisfied = proofEstablishesSatisfaction(skipProof);
+      if (alreadySatisfied) {
+        const driftContext = computeCompetitionDrift([], expectedAllowlistForSkip, effectiveMode);
+        const coherenceMetrics = computeCoherenceMetrics(
+          [],
+          DEFAULT_COHERENCE_THRESHOLD,
+          expectedAllowlistForSkip
+        );
+        try {
+          await artifactStore.save(stage.id, "stage-change", "json", {
+            stageId: stage.id,
+            stageType: "competition",
+            mode: effectiveMode,
+            deliveredFiles: driftContext.deliveredFiles,
+            expectedFiles: driftContext.expectedFiles,
+            violations: driftContext.violations,
+            hasDrift: driftContext.hasDrift,
+            candidateCount: 0,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            skipped: true,
+            reason: "already-satisfied"
+          });
+          await artifactStore.save(
+            stage.id,
+            "stage-change-summary",
+            "text",
+            `${driftContext.summary}
+
+Skipped: stage already satisfied`
+          );
+          const rationalePacket = {
+            winnerId: "none",
+            scores: {},
+            candidateAnalysis: [],
+            selectionRationale: {
+              primary: "Competition skipped: stage already satisfied by deterministic checks",
+              keyFactors: [
+                "deterministic validation checks passed",
+                "validation.requireChanges=false",
+                "no variants executed"
+              ],
+              confidence: 100
+            },
+            rejectionReasons: {},
+            suggestedImprovements: []
+          };
+          await artifactStore.save(stage.id, "judgeRationale", "json", rationalePacket);
+          await artifactStore.save(stage.id, "winnerDiff", "diff", "");
+        } catch {
+        }
+        return {
+          stageId: stage.id,
+          stageType: "competition",
+          validationPassed: true,
+          validationScore: 100,
+          cost: 0,
+          summary: "Competition skipped: stage already satisfied (idempotent)",
+          durationMs: Date.now() - startTime,
+          candidates: [],
+          winner: null,
+          winnerApplied: false,
+          coherenceMetrics,
+          markedIncomparable: false,
+          scoringMode: "deterministic",
+          competitionJudgeResult: {
+            judgeType: config.judgeConfig?.type ?? "ai",
+            aiJudgeAttempted: false,
+            aiJudgeInvoked: false,
+            aiJudgeError: void 0,
+            judgeInvocationReason: "deterministic-shortcut",
+            rankings: [],
+            wasTie: false
+          },
+          driftContext,
+          ...skipProof.evidence ? { completionEvidence: skipProof.evidence } : {}
+        };
+      }
+    } catch {
+    }
+  }
+  validateWorkflowJudgeModels(config, options.workerCwd);
+  const executionIntent = resolveCompetitionExecutionIntent(stage);
+  const variantConfigs = assignDuplicateVariantInstanceIds(
+    config.variants.map(
+      (spec) => variantSpecToConfig(
+        spec,
+        executionIntent,
+        stage,
+        options.providerExecutionTransport,
+        config.executionContract
+      )
+    )
+  );
+  const admittedSpecs = admitFlywheelVariantSpecs(config.variants, variantConfigs);
+  const allowDuplicateVariantSpecs = config.allowDuplicateVariantSpecs ?? config.allowDuplicateStrategies;
+  if (config.allowDuplicateVariantSpecs !== void 0 && config.allowDuplicateStrategies !== void 0 && config.allowDuplicateVariantSpecs !== config.allowDuplicateStrategies) {
+    throw new Error(
+      `Invalid competition config for stage '${stage.id}': \`competition.allowDuplicateVariantSpecs\` and \`competition.allowDuplicateStrategies\` are both set but differ. Use \`competition.allowDuplicateVariantSpecs\` and remove the deprecated \`competition.allowDuplicateStrategies\`.`
+    );
+  }
+  assertNoDuplicateVariantSpecs(variantConfigs, {
+    allowDuplicates: allowDuplicateVariantSpecs
+  });
+  const taskId = generateCompetitionId();
+  const flywheelProjectRoot = getProjectRoot();
+  const declaredVerifyCommands = (stage.verify?.commands ?? []).filter(
+    (command) => command.trim().length > 0
+  );
+  const candidateGateCommands = Array.from(
+    /* @__PURE__ */ new Set([...config.candidateGate?.commands ?? [], ...declaredVerifyCommands])
+  );
+  const preserveCandidateWorktrees = config.preserveCandidates === true || Boolean(config.candidateGate) || candidateGateCommands.length > 0;
+  const competitionOptions = {
+    abortSignal: options.abortSignal,
+    workerCwd: options.workerCwd,
+    verbose: options.verbose,
+    maxConcurrentVariants: options.maxConcurrentVariants,
+    perVariantTimeoutMinutes: options.perVariantTimeoutMinutes,
+    timeoutMinutes: options.timeoutMinutes,
+    // Flywheel never consumes basic-competition synthesis (candidate gates / judge /
+    // apply use variant results only). Always disable synthesis at this boundary so
+    // agentic synthesis compute is not spent on discarded product. (Candidate gates
+    // also run after Basic Competition returns, so early synthesis cannot see that
+    // evidence and can emit misleading "0 eligible variants" warnings.)
+    synthesize: false,
+    deferEvaluationHandleFinalization: true,
+    // Preserve worktrees only when needed for post-processing (candidate gate commands,
+    // declared verify commands, coverage parsing).
+    // Winner application in flywheel-executor prefers `worktreeDiff` and does not require retained worktrees.
+    preserveWorktrees: preserveCandidateWorktrees,
+    executionContext: createExecutionContext({
+      repoRoot: flywheelProjectRoot,
+      buildDir: path.join(flywheelProjectRoot, ".build-project"),
+      taskId,
+      envOverrides: preserveCandidateWorktrees ? {
+        BUILD_PRESERVE_WORKTREES: "1",
+        BUILD_RETAIN_BASIC_WORKTREE: "1"
+      } : {}
+    })
+  };
+  let basicResult;
+  try {
+    basicResult = await runBasicCompetition(
+      taskId,
+      resolvedPrompt,
+      variantConfigs,
+      competitionOptions
+    );
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    await finalizeEvaluationHandleAsync(
+      taskId,
+      createEvaluationHandleFinalState({
+        outcome: "error",
+        winner: null,
+        errorMessage: errorMsg
+      })
+    );
+    const result = {
+      stageId: stage.id,
+      stageType: "competition",
+      validationPassed: false,
+      cost: 0,
+      candidates: [],
+      winner: null,
+      summary: `Competition execution failed: ${errorMsg}`,
+      durationMs: Date.now() - startTime,
+      competitionJudgeResult: {
+        judgeType: config.judgeConfig?.type ?? "ai",
+        aiJudgeAttempted: false,
+        aiJudgeInvoked: false,
+        aiJudgeError: errorMsg,
+        judgeInvocationReason: "error",
+        rankings: [],
+        wasTie: false,
+        noWinnerReason: "judge-error"
+      }
+    };
+    return result;
+  }
+  let deferredHandleFinalized = false;
+  const finalizeDeferredHandle = async (state) => {
+    let finalizeResult = await finalizeEvaluationHandleAsync(taskId, state);
+    if (finalizeResult.kind === "not_terminal") {
+      await Promise.all(
+        basicResult.variants.map(
+          (variant) => updateEvaluationHandleWithResultAsync(taskId, variant)
+        )
+      );
+      finalizeResult = await finalizeEvaluationHandleAsync(taskId, state);
+    }
+    if (finalizeResult.kind !== "absent" && !isDurableHandleCompletion(finalizeResult, state.status)) {
+      throw new Error(
+        `Evaluation handle did not reach durable ${state.status} state (kind=${finalizeResult.kind})`
+      );
+    }
+    deferredHandleFinalized = true;
+  };
+  let observedCandidates;
+  let aiJudgeAttempted = false;
+  let aiJudgeInvoked = false;
+  let tieBreakAiJudgeInvoked = false;
+  try {
+    const basicInterruption = resolveBasicCompetitionInterruption(basicResult);
+    let bindingError;
+    try {
+      bindFlywheelVariantResults(admittedSpecs, basicResult.variants);
+    } catch (error) {
+      observedCandidates = basicResult.variants.map(
+        (variant) => variantResultToCandidate(observedVariantSpec(variant), variant)
+      );
+      if (!basicInterruption) throw error;
+      bindingError = error instanceof Error ? error.message : String(error);
+    }
+    if (basicInterruption) {
+      const interruptedCandidates = observedCandidates ?? admittedSpecs.map(
+        (spec) => variantResultToCandidate(spec, matchVariantResult(spec, basicResult.variants))
+      );
+      observedCandidates = interruptedCandidates;
+      const { cost, costUnavailableReason: costUnavailableReason2 } = resolveCompetitionCostAggregate(interruptedCandidates);
+      const timedOut = basicInterruption.kind === "timed_out";
+      await finalizeDeferredHandle(
+        timedOut ? createEvaluationHandleFinalState({
+          outcome: "timed_out",
+          winner: null,
+          errorMessage: `Competition timed out after ${basicInterruption.timeout.timeoutMs}ms`
+        }) : createEvaluationHandleFinalState({ outcome: "no_winner", winner: null })
+      );
+      await cleanupSynthesisInputPatches(basicResult.variants, {
+        expectedRoot: resolveSynthesisInputPatchDir(
+          competitionOptions.executionContext.buildDir,
+          taskId
+        )
+      });
+      return {
+        stageId: stage.id,
+        stageType: "competition",
+        validationPassed: false,
+        cost,
+        costUnavailableReason: costUnavailableReason2,
+        candidates: interruptedCandidates,
+        warnings: bindingError ? [bindingError] : void 0,
+        winner: null,
+        summary: timedOut ? "Competition timed out; no winner selected" : `Competition canceled by ${basicInterruption.kind === "canceled" ? basicInterruption.signal : "unknown signal"}; no winner selected`,
+        durationMs: Date.now() - startTime,
+        competitionJudgeResult: {
+          judgeType: config.judgeConfig?.type ?? "ai",
+          aiJudgeAttempted: false,
+          aiJudgeInvoked: false,
+          judgeInvocationReason: timedOut ? "error" : "canceled",
+          rankings: [],
+          wasTie: false,
+          noWinnerReason: timedOut ? "judge-error" : "canceled"
+        }
+      };
+    }
+    let judgedWinner = null;
+    let aiJudgeError;
+    let latestJudgeEscalation;
+    let latestMainJudgeResult;
+    let latestTiebreakJudgeResult;
+    let matrixDefaultWinnerSource = "unknown";
+    let eligibleVariantResultsForMatrix = [];
+    let matrixRan = false;
+    let matrixProfileAgreement;
+    let effectiveMatrixAuthority;
+    const matrixAuthorityWarnings = [];
+    const matrixAuthorityNonSelectionReasons = [];
+    const candidates = await Promise.all(
+      admittedSpecs.map(async (spec) => {
+        const matchingResult = matchVariantResult(spec, basicResult.variants);
+        const candidate = variantResultToCandidate(spec, matchingResult);
+        if (candidate.success) return candidate;
+        if (!isNoChangesDetectedError(candidate.error)) return candidate;
+        if (requireChangesDemandsEdits) {
+          return candidate;
+        }
+        if (!stageHasDeterministicChecks(stage)) return candidate;
+        if (!candidate.worktreePath) return candidate;
+        const stdout = getStringAtPath(matchingResult, ["result", "stdout"]) ?? "";
+        const canAcceptNoop = await validateWorktreeAgainstStageChecks(
+          stage,
+          candidate.worktreePath,
+          stdout,
+          {
+            attemptChangedFiles: candidate.changedFiles ?? [],
+            allowlist: expectedAllowlistForSkip
+          }
+        );
+        if (!canAcceptNoop) return candidate;
+        return {
+          ...candidate,
+          success: true,
+          error: void 0,
+          score: candidate.score ?? 0
+        };
+      })
+    );
+    observedCandidates = candidates;
+    const finishedExecutionKeys = new Set(
+      candidates.filter((c) => c.success).map((c) => variantIdForSpec(c.variant))
+    );
+    if (stage.validation?.requireChanges === true && stage.allowEmptyResults !== true) {
+      for (let idx = 0; idx < candidates.length; idx++) {
+        const candidate = candidates[idx];
+        if (!candidate?.success || !candidateHasConcreteZeroChanges(candidate)) continue;
+        candidates[idx] = {
+          ...candidate,
+          success: false,
+          error: "Candidate produced no applicable changes but validation.requireChanges is enabled"
+        };
+      }
+    }
+    await hydrateCandidateCostsFromTelemetry(taskId, candidates, stage.id, options.verbose);
+    const verificationPolicy = config.verificationPolicy ?? "findings";
+    const candidatesWithTestFindings = [];
+    for (let idx = 0; idx < candidates.length; idx++) {
+      const candidate = candidates[idx];
+      if (!candidate) continue;
+      const trustedTestStatus = resolveTrustedCandidateTestStatus(candidate);
+      if (candidate.success && candidate.testsExecuted && trustedTestStatus && trustedTestStatus !== "passed" && trustedTestStatus !== "not_run") {
+        const variantId = formatCompetitionCandidateVariantDisplay(candidate);
+        const testScope = candidate.testsExecuted.scope ?? "unknown";
+        const exitCode = candidate.testsExecuted.exitCode ?? 1;
+        const testLabel = `touched tests (scope: ${testScope})`;
+        const verificationUnavailable = candidate.testStatus === "unavailable";
+        const finding = {
+          kind: "test",
+          command: testLabel,
+          exitCode,
+          severity: verificationUnavailable ? "warning" : "error",
+          recommendedNextStep: verificationUnavailable ? `Install or enable test tooling for scope: ${testScope}` : `Fix failing tests in scope: ${testScope}`
+        };
+        candidate.verification = {
+          passed: false,
+          findings: [finding]
+        };
+        if (verificationPolicy === "blocking") {
+          candidatesWithTestFindings.push(
+            `${variantId} (${verificationUnavailable ? "verification unavailable" : "disqualified"})`
+          );
+          candidates[idx] = {
+            ...candidate,
+            success: false,
+            error: verificationUnavailable ? `Candidate gate unavailable: touched tests unavailable (scope: ${testScope})` : `Candidate gate failed: touched tests ${candidate.testStatus} (scope: ${testScope})`
+          };
+        } else {
+          candidatesWithTestFindings.push(`${variantId} (findings recorded)`);
+        }
+      }
+    }
+    if (candidatesWithTestFindings.length > 0 && options.verbose) {
+      const mode = verificationPolicy === "blocking" ? "disqualified" : "recorded findings for";
+      console.log(
+        chalk.yellow(
+          `   ${candidatesWithTestFindings.length} candidate(s) ${mode}: ${candidatesWithTestFindings.join(", ")}`
+        )
+      );
+    }
+    const candidateGatePassedVariantIds = /* @__PURE__ */ new Set();
+    if (candidateGateCommands.length > 0) {
+      const gate = { ...config.candidateGate ?? {}, commands: candidateGateCommands };
+      const gateResults = [];
+      const gatedCandidates = await Promise.all(
+        candidates.map(async (candidate) => {
+          if (!candidate.success) {
+            gateResults.push({
+              provider: candidate.variant.provider,
+              model: candidate.variant.model,
+              worktreePath: candidate.worktreePath,
+              ran: false,
+              passed: false,
+              error: "Candidate did not execute successfully (gate not run)",
+              commandResults: []
+            });
+            return candidate;
+          }
+          if (!candidate.worktreePath) {
+            const msg = "Candidate gate requires a retained worktreePath but none was provided";
+            gateResults.push({
+              provider: candidate.variant.provider,
+              model: candidate.variant.model,
+              worktreePath: candidate.worktreePath,
+              ran: false,
+              passed: false,
+              error: msg,
+              commandResults: []
+            });
+            return { ...candidate, success: false, error: `Candidate gate failed: ${msg}` };
+          }
+          const findings = [
+            ...candidate.verification?.findings ?? []
+          ];
+          const renderedCommands = gate.commands.map(
+            (command) => renderCandidateGateCommand(command, candidate)
+          );
+          const verifyResult = await runVerifyCommands({
+            cwd: candidate.worktreePath,
+            commands: renderedCommands,
+            commandProvenance: "candidate-gate-config",
+            timeoutMs: CANDIDATE_GATE_COMMAND_TIMEOUT_MS
+          });
+          const commandResults = verifyResult.results;
+          const gatePassed = verifyResult.passed;
+          if (gatePassed) {
+            candidateGatePassedVariantIds.add(variantIdForSpec(candidate.variant));
+          }
+          let gateError;
+          const failedCommand = commandResults.find((result2) => result2.exitCode !== 0);
+          if (failedCommand) {
+            gateError = `Verify command failed (exit ${failedCommand.exitCode}): ${failedCommand.command}`;
+            findings.push({
+              kind: "gate-command",
+              command: failedCommand.command,
+              exitCode: failedCommand.exitCode,
+              outputTail: failedCommand.outputTail ?? failedCommand.stderrTail ?? failedCommand.stdoutTail,
+              severity: "error",
+              recommendedNextStep: `Fix gate command failure: ${failedCommand.command}`
+            });
+          }
+          gateResults.push({
+            provider: candidate.variant.provider,
+            model: candidate.variant.model,
+            worktreePath: candidate.worktreePath,
+            ran: true,
+            passed: gatePassed,
+            error: gateError,
+            commandResults
+          });
+          if (!gatePassed) {
+            candidate.verification = {
+              passed: false,
+              findings
+            };
+            if (verificationPolicy === "blocking") {
+              return { ...candidate, success: false, error: `Candidate gate failed: ${gateError}` };
+            }
+          }
+          return candidate;
+        })
+      );
+      candidates.splice(0, candidates.length, ...gatedCandidates);
+      try {
+        await artifactStore.save(stage.id, "candidate-gates", "json", {
+          taskId,
+          stageId: stage.id,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          commands: gate.commands,
+          candidateCount: candidates.length,
+          passedCount: gateResults.filter((r) => r.passed).length,
+          results: gateResults
+        });
+      } catch (error) {
+        if (options.verbose) {
+          console.warn(
+            chalk.yellow(`   Warning: Failed to persist candidate gate artifacts: ${error}`)
+          );
+        }
+      }
+    }
+    const coverageConfig = config.candidateGate?.coverage;
+    let usedCoverageScoring = false;
+    let coverageDataAvailable = false;
+    if (coverageConfig && Array.isArray(coverageConfig.targets) && coverageConfig.targets.length > 0) {
+      const summaryPath = coverageConfig.summaryPath ?? "coverage/coverage-summary.json";
+      const threshold = coverageConfig.threshold;
+      const coverageMode = coverageConfig.mode ?? "absolute";
+      const minDeltaPct = coverageConfig.minDeltaPct ?? 15;
+      const largeFileLineThreshold = coverageConfig.largeFileLineThreshold ?? 300;
+      const baselineSummary = typeof options.workerCwd === "string" && options.workerCwd.length > 0 ? await loadCoverageSummaryJson(options.workerCwd, summaryPath) : null;
+      const baselineStats = computeCoverageStatsForTargets(baselineSummary, coverageConfig.targets);
+      const baselineFromPrompt = parseBaselineLinesPctFromPrompt(resolvedPrompt);
+      const effectiveBaselineAvgPct = baselineStats.avgPct ?? baselineFromPrompt;
+      const perCandidateCoverage = [];
+      for (let idx = 0; idx < candidates.length; idx++) {
+        const candidate = candidates[idx];
+        if (!candidate) continue;
+        const worktreePath = candidate.worktreePath;
+        let avgPct = null;
+        let minPct = null;
+        let maxTargetLines = null;
+        let byTarget = {};
+        let missingTargets = [];
+        let disqualified = false;
+        let disqualifyReason;
+        let deltaAvgPct = null;
+        const baselineAvgPct = effectiveBaselineAvgPct;
+        if (candidate.success) {
+          if (!worktreePath) {
+            byTarget = Object.fromEntries(coverageConfig.targets.map((t) => [t, null]));
+            missingTargets = [...coverageConfig.targets];
+            const hasGateConfig = typeof threshold === "number" || coverageMode === "delta" || coverageMode === "auto";
+            if (hasGateConfig) {
+              disqualified = true;
+              disqualifyReason = "Missing worktreePath required for coverage gate evaluation";
+            }
+          } else {
+            const candidateSummary = await loadCoverageSummaryJson(worktreePath, summaryPath);
+            const stats = computeCoverageStatsForTargets(candidateSummary, coverageConfig.targets);
+            avgPct = stats.avgPct;
+            minPct = stats.minPct;
+            maxTargetLines = stats.maxTargetLines;
+            byTarget = stats.byTarget;
+            missingTargets = stats.missingTargets;
+            deltaAvgPct = typeof avgPct === "number" ? Math.round(
+              (avgPct - (typeof baselineAvgPct === "number" ? baselineAvgPct : 0)) * 100
+            ) / 100 : null;
+            let effectiveMode2 = coverageMode;
+            if (coverageMode === "auto" && typeof maxTargetLines === "number") {
+              effectiveMode2 = resolveAutoCoverageMode({
+                maxTargetLines,
+                largeFileLineThreshold,
+                baselineAvgPct,
+                threshold,
+                minDeltaPct
+              });
+            }
+            if (effectiveMode2 === "absolute" && typeof threshold === "number") {
+              if (missingTargets.length > 0) {
+                disqualified = true;
+                disqualifyReason = `Missing coverage for targets: ${missingTargets.join(", ")}`;
+              } else if (typeof minPct === "number" && minPct < threshold) {
+                disqualified = true;
+                disqualifyReason = `Coverage below threshold (${minPct.toFixed(1)}% < ${threshold}%)`;
+              } else if (minPct === null) {
+                disqualified = true;
+                disqualifyReason = "Coverage data missing (unable to evaluate threshold)";
+              }
+            } else if (effectiveMode2 === "delta") {
+              if (missingTargets.length > 0) {
+                disqualified = true;
+                disqualifyReason = `Missing coverage for targets: ${missingTargets.join(", ")}`;
+              } else if (typeof deltaAvgPct === "number" && deltaAvgPct < minDeltaPct) {
+                disqualified = true;
+                disqualifyReason = `Coverage improvement below minimum (${deltaAvgPct.toFixed(1)}pp < ${minDeltaPct}pp)`;
+              } else if (deltaAvgPct === null) {
+                disqualified = true;
+                disqualifyReason = "Coverage data missing (unable to evaluate delta)";
+              }
+            }
+          }
+        }
+        let effectiveCandidate = candidate;
+        if (effectiveCandidate.success && disqualified) {
+          effectiveCandidate = {
+            ...effectiveCandidate,
+            success: false,
+            error: `Candidate gate failed: ${disqualifyReason ?? "coverage threshold"}`
+          };
+          candidates[idx] = effectiveCandidate;
+        }
+        if (effectiveCandidate.success && typeof avgPct === "number") {
+          effectiveCandidate = { ...effectiveCandidate, score: avgPct };
+          candidates[idx] = effectiveCandidate;
+          coverageDataAvailable = true;
+        }
+        perCandidateCoverage.push({
+          provider: effectiveCandidate.variant.provider,
+          model: effectiveCandidate.variant.model,
+          worktreePath,
+          success: effectiveCandidate.success,
+          avgPct,
+          minPct,
+          maxTargetLines,
+          baselineAvgPct,
+          deltaAvgPct,
+          byTarget,
+          missingTargets,
+          disqualified: disqualified || void 0,
+          disqualifyReason
+        });
+      }
+      try {
+        await artifactStore.save(stage.id, "candidate-coverage", "json", {
+          taskId,
+          stageId: stage.id,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          summaryPath,
+          gateConfig: {
+            mode: coverageMode,
+            threshold,
+            minDeltaPct,
+            largeFileLineThreshold
+          },
+          targets: coverageConfig.targets,
+          baseline: {
+            avgPct: effectiveBaselineAvgPct,
+            minPct: baselineStats.minPct ?? baselineFromPrompt,
+            totalLines: baselineStats.totalLines,
+            maxTargetLines: baselineStats.maxTargetLines,
+            byTarget: baselineStats.byTarget,
+            missingTargets: baselineStats.missingTargets
+          },
+          candidates: perCandidateCoverage
+        });
+      } catch (error) {
+        if (options.verbose) {
+          console.warn(
+            chalk.yellow(`   Warning: Failed to persist candidate coverage artifacts: ${error}`)
+          );
+        }
+      }
+      usedCoverageScoring = coverageDataAvailable;
+    }
+    recordDeterministicTestSignalObservation(candidates, options.verbose);
+    const expectedAllowlist = computeExpectedAllowlist(stage);
+    const { cost: totalCost, costUnavailableReason } = resolveCompetitionCostAggregate(candidates);
+    const finishedCandidates = candidates.filter(
+      (c) => finishedExecutionKeys.has(variantIdForSpec(c.variant))
+    );
+    const shouldInvokeAiJudgeForFinished = finishedCandidates.length >= 2 && config.judgeConfig?.disableAiJudge !== true;
+    const allCandidatesDisqualified = candidates.every((c) => !c.success);
+    if (allCandidatesDisqualified && verificationPolicy === "blocking" && !shouldInvokeAiJudgeForFinished) {
+      let disqualificationSummary = "Competition failed: All candidates disqualified by verification gates";
+      const testGateUnavailable = candidates.filter(
+        (c) => c.error?.includes("touched tests unavailable")
+      );
+      const testGateFailures = candidates.filter(
+        (c) => !c.error?.includes("touched tests unavailable") && (c.error?.includes("touched tests") || c.error?.includes("Candidate gate failed"))
+      );
+      const coverageGateFailures = candidates.filter((c) => c.error?.includes("coverage"));
+      const verifyFailures = candidates.filter(
+        (c) => c.error?.includes("Verify stage failed") || c.error?.includes("verify.commands")
+      );
+      const requireChangesNoops = candidates.filter(
+        (c) => c.error?.includes("validation.requireChanges is enabled")
+      );
+      const rootCauses = [];
+      if (testGateUnavailable.length > 0) {
+        rootCauses.push(
+          `${testGateUnavailable.length} candidate(s) had unavailable deterministic test verification (touched tests unavailable)`
+        );
+      }
+      if (testGateFailures.length > 0) {
+        rootCauses.push(
+          `${testGateFailures.length} candidate(s) failed deterministic test gate (touched tests failed)`
+        );
+      }
+      if (coverageGateFailures.length > 0) {
+        rootCauses.push(
+          `${coverageGateFailures.length} candidate(s) failed coverage gate (below threshold)`
+        );
+      }
+      if (verifyFailures.length > 0) {
+        rootCauses.push(`${verifyFailures.length} candidate(s) failed verify stage commands`);
+      }
+      if (requireChangesNoops.length > 0) {
+        rootCauses.push(
+          `${requireChangesNoops.length} candidate(s) produced no applicable changes while validation.requireChanges is enabled`
+        );
+      }
+      if (rootCauses.length > 0) {
+        disqualificationSummary += `. Root cause: ${rootCauses.join("; ")}`;
+      }
+      const candidateErrors = candidates.filter((c) => c.error).map((c) => {
+        const variantId = formatCompetitionCandidateVariantDisplay(c);
+        return `${variantId} - ${c.error}`;
+      }).join("; ");
+      if (candidateErrors) {
+        disqualificationSummary += `. Candidate details: ${candidateErrors}`;
+      }
+      const result2 = {
+        stageId: stage.id,
+        stageType: "competition",
+        validationPassed: false,
+        validationScore: 0,
+        cost: totalCost,
+        costUnavailableReason,
+        summary: disqualificationSummary,
+        durationMs: Date.now() - startTime,
+        candidates,
+        winner: null,
+        winnerApplied: false,
+        scoringMode: "deterministic",
+        competitionJudgeResult: {
+          judgeType: config.judgeConfig?.type ?? "ai",
+          aiJudgeAttempted: false,
+          aiJudgeInvoked: false,
+          aiJudgeError: void 0,
+          judgeInvocationReason: "no-successful-candidates",
+          rankings: [],
+          wasTie: false,
+          noWinnerReason: "all-failed"
+        }
+      };
+      try {
+        await artifactStore.save(stage.id, "candidates", "json", {
+          taskId,
+          variantCount: candidates.length,
+          successCount: 0,
+          candidates: candidates.map((c) => ({
+            provider: c.variant.provider,
+            model: c.variant.model,
+            success: c.success,
+            error: c.error,
+            cost: c.cost,
+            costUnavailableReason: c.costUnavailableReason
+          })),
+          winner: null,
+          rankings: [],
+          allDisqualifiedByTestGate: true,
+          aiJudgeInvoked: result2.competitionJudgeResult?.aiJudgeInvoked ?? false,
+          scoringMode: result2.scoringMode ?? "deterministic",
+          judgeInvocationReason: result2.competitionJudgeResult?.judgeInvocationReason ?? "no-successful-candidates"
+        });
+      } catch (error) {
+        if (options.verbose) {
+          console.warn(chalk.yellow(`   Warning: Failed to persist failure artifacts: ${error}`));
+        }
+      }
+      await finalizeDeferredHandle(
+        createEvaluationHandleFinalState({ outcome: "all_failed", winner: null })
+      );
+      await cleanupSynthesisInputPatches(basicResult.variants, {
+        expectedRoot: resolveSynthesisInputPatchDir(
+          competitionOptions.executionContext.buildDir,
+          taskId
+        )
+      });
+      return result2;
+    }
+    const shouldInvokeAiJudge = shouldInvokeAiJudgeForFinished;
+    if (shouldInvokeAiJudge) {
+      if (options.verbose) {
+        console.log(chalk.blue("   Invoking AI judge for competition evaluation..."));
+      }
+      const judgeVisibleVariantResults = buildJudgeVisibleVariantResults(
+        finishedCandidates,
+        basicResult.variants
+      );
+      if (judgeVisibleVariantResults.length < 2) {
+        if (options.verbose) {
+          console.warn(
+            chalk.yellow(
+              `   Skipping AI judge: expected \u22652 finished variants but resolved ${judgeVisibleVariantResults.length}`
+            )
+          );
+        }
+      } else {
+        aiJudgeAttempted = true;
+        try {
+          const { aiJudgeRun, aiJudgePrimary } = deriveAiJudgeInvocationArgs(config.judgeConfig);
+          eligibleVariantResultsForMatrix = judgeVisibleVariantResults;
+          matrixDefaultWinnerSource = aiJudgePrimary;
+          const judgeResult = await selectWinnerWithJudge(
+            resolvedPrompt,
+            judgeVisibleVariantResults,
+            {
+              taskId,
+              aiJudgeTelemetry: true,
+              aiJudgeRun,
+              aiJudgePrimary,
+              anonymizeJudge: config.judgeConfig?.anonymizeJudge,
+              judgeAllowUnsafeModel: config.judgeConfig?.allowUnsafeModel === true,
+              // The flywheel owns the explicit Matrix escalation block below;
+              // opt out of the coordinator's automatic Matrix run to avoid a
+              // duplicate Matrix call.
+              autoMatrix: false
+            }
+          );
+          latestMainJudgeResult = judgeResult;
+          if (isJudgeType(judgeResult.synthesisContext?.selectedJudge)) {
+            matrixDefaultWinnerSource = judgeResult.synthesisContext.selectedJudge;
+          }
+          latestJudgeEscalation = judgeResult.decision?.escalation;
+          judgedWinner = judgeResult.winner;
+          aiJudgeInvoked = true;
+          for (const candidate of candidates) {
+            if (!finishedExecutionKeys.has(variantIdForSpec(candidate.variant))) continue;
+            const matchingResult = matchVariantResult(candidate.variant, basicResult.variants);
+            if (!matchingResult) continue;
+            const updated = variantResultToCandidate(candidate.variant, matchingResult);
+            candidate.score = updated.score;
+            candidate.feedback = updated.feedback;
+          }
+          recordDeterministicTestSignalObservation(candidates, options.verbose);
+          if (options.verbose) {
+            console.log(chalk.green("   ok AI judge evaluation complete"));
+          }
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          if (options.verbose) {
+            console.warn(chalk.yellow(`   AI judge invocation failed: ${errorMsg}`));
+          }
+          aiJudgeError = errorMsg;
+          aiJudgeInvoked = false;
+        }
+      }
+    }
+    let winnerInfo = aiJudgeInvoked ? buildWinnerInfoFromJudgeVerdict(candidates, judgedWinner, finishedCandidates) : determineWinner(candidates, config, expectedAllowlist);
+    if (aiJudgeError && shouldInvokeAiJudge) {
+      winnerInfo = {
+        winner: null,
+        rankings: [],
+        wasTie: false,
+        noWinnerReason: "judge-error",
+        tieBreaker: void 0
+      };
+    }
+    if (!aiJudgeInvoked && usedCoverageScoring && winnerInfo.wasTie && config.judgeConfig && candidates.length > 1) {
+      const successful = candidates.filter((c) => c.success && typeof c.score === "number");
+      const SCORE_COLLISION_DECIMALS = 6;
+      const SCORE_COLLISION_MULTIPLIER = 10 ** SCORE_COLLISION_DECIMALS;
+      const quantizeScore = (score) => {
+        if (!Number.isFinite(score)) return 0;
+        return Math.round(score * SCORE_COLLISION_MULTIPLIER) / SCORE_COLLISION_MULTIPLIER;
+      };
+      const topScoreRaw = successful.reduce((max, c) => Math.max(max, c.score ?? 0), -Infinity);
+      const topScoreQuantized = quantizeScore(topScoreRaw);
+      const tiedAtTop = successful.filter(
+        (c) => quantizeScore(Number(c.score ?? 0)) === topScoreQuantized
+      );
+      if (tiedAtTop.length >= 2) {
+        const first = tiedAtTop[0];
+        const getCandidateChangedFileCount = (candidate) => Array.isArray(candidate.changedFiles) ? candidate.changedFiles.length : 0;
+        const getCandidateDriftViolations = (candidate) => {
+          if (!Array.isArray(candidate.changedFiles) || candidate.changedFiles.length === 0)
+            return 0;
+          if (!Array.isArray(expectedAllowlist) || expectedAllowlist.length === 0) return 0;
+          return findAllowlistViolations(candidate.changedFiles, expectedAllowlist).length;
+        };
+        const allSameDrift = first ? tiedAtTop.every(
+          (c) => getCandidateDriftViolations(c) === getCandidateDriftViolations(first)
+        ) : false;
+        const allSameDiff = first ? tiedAtTop.every(
+          (c) => getCandidateChangedFileCount(c) === getCandidateChangedFileCount(first)
+        ) : false;
+        if (allSameDrift && allSameDiff && typeof options.workerCwd === "string") {
+          try {
+            const { aiJudgeRun, aiJudgePrimary } = deriveAiJudgeInvocationArgs(config.judgeConfig);
+            const tiedVariantResults = tiedAtTop.map((candidate) => matchVariantResult(candidate.variant, basicResult.variants)).filter(Boolean);
+            if (tiedVariantResults.length >= 2) {
+              const tiebreakJudgeResult = await selectWinnerWithJudge(
+                resolvedPrompt,
+                tiedVariantResults,
+                {
+                  taskId,
+                  evaluationPhase: "tiebreak",
+                  aiJudgeTelemetry: true,
+                  aiJudgeRun,
+                  aiJudgePrimary,
+                  anonymizeJudge: config.judgeConfig?.anonymizeJudge,
+                  judgeAllowUnsafeModel: config.judgeConfig?.allowUnsafeModel === true,
+                  // Matrix escalation for this stage is owned by the explicit
+                  // block keyed off the main judge's escalation; keep the
+                  // tie-breaker from launching its own automatic Matrix run.
+                  autoMatrix: false
+                }
+              );
+              latestTiebreakJudgeResult = tiebreakJudgeResult;
+              const tiebreakWinner = tiebreakJudgeResult.winner;
+              if (tiebreakWinner) {
+                const winningCandidate = findCandidateForVariantResult(candidates, tiebreakWinner);
+                if (winningCandidate) {
+                  tieBreakAiJudgeInvoked = true;
+                  winnerInfo = {
+                    ...winnerInfo,
+                    winner: winningCandidate
+                  };
+                }
+              }
+            }
+          } catch (error) {
+            if (options.verbose) {
+              console.warn(chalk.yellow(`   AI judge tie-breaker failed: ${String(error)}`));
+            }
+          }
+        }
+      }
+    }
+    const defaultWinnerCandidate = winnerInfo.winner;
+    if (latestJudgeEscalation?.recommended === "matrix" && eligibleVariantResultsForMatrix.length >= 2) {
+      const matrixPolicy = resolveMatrixAuthorityPolicy(config.judgeConfig?.matrixAuthority);
+      effectiveMatrixAuthority = matrixPolicy;
+      try {
+        const matrixCoordinator = new JudgeCoordinator();
+        const matrixResult = await matrixCoordinator.evaluateProfileMatrix(
+          eligibleVariantResultsForMatrix,
+          resolvedPrompt,
+          {
+            taskId,
+            anonymizeJudge: config.judgeConfig?.anonymizeJudge,
+            judgeAllowUnsafeModel: config.judgeConfig?.allowUnsafeModel === true,
+            evaluationContext: latestMainJudgeResult?.evaluationContext,
+            matrixEscalationContext: {
+              reasons: latestJudgeEscalation.reasons
+            }
+          }
+        );
+        const defaultWinnerResult = defaultWinnerCandidate ? matchVariantResult(defaultWinnerCandidate.variant, basicResult.variants) : void 0;
+        const defaultWinner = defaultWinnerResult ? `${defaultWinnerResult.provider}:${defaultWinnerResult.variant}` : "none";
+        const authorityDecision = evaluateMatrixAuthority({
+          policy: matrixPolicy,
+          defaultWinner,
+          defaultWinnerSource: matrixDefaultWinnerSource,
+          matrixEvaluatorType: matrixResult.matrixEvaluatorType,
+          matrixResult,
+          variants: eligibleVariantResultsForMatrix
+        });
+        matrixRan = true;
+        matrixProfileAgreement = authorityDecision.profileAgreement;
+        if (authorityDecision.selectedByMatrix && authorityDecision.matrixWinner && isAcceptedMatrixVerdict(authorityDecision.winnerStatus)) {
+          const matrixWinnerCandidate = findCandidateForVariantResult(
+            candidates,
+            authorityDecision.matrixWinner
+          );
+          if (matrixWinnerCandidate) {
+            winnerInfo = {
+              ...winnerInfo,
+              winner: matrixWinnerCandidate
+            };
+          } else {
+            matrixAuthorityWarnings.push(
+              "Matrix authority selected a variant that could not be resolved to a candidate"
+            );
+          }
+        } else {
+          if (!isAcceptedMatrixVerdict(authorityDecision.winnerStatus) && authorityDecision.nonSelectionReasons.length === 0) {
+            matrixAuthorityNonSelectionReasons.push(
+              `matrix winner status is ${authorityDecision.winnerStatus}`
+            );
+          }
+          if (authorityDecision.winnerStatus === "conditional") {
+            matrixAuthorityNonSelectionReasons.push(
+              ...authorityDecision.winnerCaveats.slice(0, 3)
+            );
+          }
+          if (authorityDecision.nonSelectionReasons.length > 0) {
+            matrixAuthorityNonSelectionReasons.push(
+              ...authorityDecision.nonSelectionReasons.slice(0, 3)
+            );
+          }
+        }
+      } catch (error) {
+        matrixAuthorityWarnings.push(`Matrix authority evaluation failed: ${String(error)}`);
+      }
+    }
+    const successCount = candidates.filter((c) => c.success).length;
+    const persistedAiJudgeInvoked = tieBreakAiJudgeInvoked || aiJudgeInvoked;
+    const persistedScoringMode = aiJudgeInvoked ? "ai-judge" : tieBreakAiJudgeInvoked ? "hybrid" : "deterministic";
+    const persistedJudgeInvocationReason = aiJudgeError ? "error" : tieBreakAiJudgeInvoked || aiJudgeInvoked ? "multiple-successful-candidates" : successCount === 0 ? "no-successful-candidates" : successCount === 1 ? "single-successful-candidate" : "deterministic-shortcut";
+    const judgeResultForEvidence = latestMainJudgeResult ?? latestTiebreakJudgeResult;
+    const hasNewJudgeSchemaFields = config.judgeConfig?.judgeRun !== void 0 || config.judgeConfig?.matrixAuthority !== void 0 || matrixRan;
+    const persistedMatrixAuthority = effectiveMatrixAuthority ?? (config.judgeConfig?.matrixAuthority !== void 0 ? resolveMatrixAuthorityPolicy(config.judgeConfig.matrixAuthority) : void 0);
+    const { judgeRunRequested } = deriveAiJudgeInvocationArgs(config.judgeConfig);
+    const multiJudgeEvidence = hasNewJudgeSchemaFields ? buildMultiJudgeEvidenceBlock({
+      judgeResult: judgeResultForEvidence,
+      judgeRunRequested,
+      matrixAuthority: persistedMatrixAuthority,
+      matrixRan,
+      matrixProfileAgreement,
+      matrixNonSelectionReasons: matrixAuthorityNonSelectionReasons
+    }) : void 0;
+    try {
+      await artifactStore.save(stage.id, "candidates", "json", {
+        taskId,
+        variantCount: candidates.length,
+        successCount: candidates.filter((c) => c.success).length,
+        candidates: candidates.map((c) => ({
+          provider: c.variant.provider,
+          model: c.variant.model,
+          success: c.success,
+          score: c.score,
+          error: c.error,
+          cost: c.cost,
+          costUnavailableReason: c.costUnavailableReason
+        })),
+        winner: winnerInfo.winner ? {
+          provider: winnerInfo.winner.variant.provider,
+          model: winnerInfo.winner.variant.model,
+          score: winnerInfo.winner.score
+        } : null,
+        rankings: winnerInfo.rankings,
+        aiJudgeInvoked: persistedAiJudgeInvoked,
+        scoringMode: persistedScoringMode,
+        judgeInvocationReason: persistedJudgeInvocationReason,
+        ...multiJudgeEvidence ? { multiJudgeEvidence } : {}
+      });
+      await artifactStore.save(
+        stage.id,
+        "bundle",
+        "text",
+        buildCompetitionBundle(taskId, candidates, basicResult)
+      );
+      if (winnerInfo.winner) {
+        await artifactStore.save(stage.id, "winner", "json", {
+          variant: winnerInfo.winner.variant,
+          score: winnerInfo.winner.score,
+          feedback: winnerInfo.winner.feedback,
+          commitSha: winnerInfo.winner.commitSha,
+          changedFiles: winnerInfo.winner.changedFiles
+        });
+      }
+      const winnerResult = winnerInfo.winner ? matchVariantResult(winnerInfo.winner.variant, basicResult.variants) : void 0;
+      const winnerDiff = typeof winnerResult?.worktreeDiff === "string" ? winnerResult.worktreeDiff : "";
+      await artifactStore.save(stage.id, "winnerDiff", "diff", winnerDiff);
+      let rationalePacket = basicResult.variants.find((v) => v.judgeEvaluation?.rationalePacket)?.judgeEvaluation?.rationalePacket;
+      if (!rationalePacket) {
+        rationalePacket = synthesizeDeterministicRationalePacket(candidates, winnerInfo, config);
+      } else {
+        const judgedCandidate = judgeResultForEvidence ? judgeResultForEvidence.winner ? findCandidateForVariantResult(candidates, judgeResultForEvidence.winner) : null : void 0;
+        rationalePacket = reconcileJudgeRationaleWinner(
+          rationalePacket,
+          judgedCandidate,
+          winnerInfo.winner,
+          judgeResultForEvidence !== void 0
+        );
+      }
+      await artifactStore.save(stage.id, "judgeRationale", "json", rationalePacket);
+      for (const [index, candidate] of candidates.entries()) {
+        const artifactName = `candidate-${candidate.variant.provider ? `${candidate.variant.provider}-` : ""}${index + 1}`;
+        const matchingResult = matchVariantResult(candidate.variant, basicResult.variants);
+        await artifactStore.save(stage.id, artifactName, "json", {
+          candidate,
+          variantResult: matchingResult ? {
+            provider: matchingResult.provider,
+            model: matchingResult.model,
+            success: matchingResult.success,
+            completeness: matchingResult.completeness,
+            judgeScore: matchingResult.judgeScore,
+            worktreeDiff: matchingResult.worktreeDiff,
+            worktreeDiffReplayable: matchingResult.worktreeDiffReplayable,
+            baselineRef: matchingResult.baselineRef,
+            worktreeSummary: matchingResult.worktreeSummary,
+            retainedWorktreePath: matchingResult.retainedWorktreePath,
+            logFilePath: matchingResult.logFilePath,
+            logTail: matchingResult.logTail,
+            costMetrics: matchingResult.costMetrics,
+            error: matchingResult.error?.message
+          } : null
+        });
+        candidate.resultArtifactPath = `${stage.id}.${artifactName}`;
+      }
+    } catch (error) {
+      if (options.verbose) {
+        console.warn(chalk.yellow(`   Warning: Failed to persist competition artifacts: ${error}`));
+      }
+    }
+    const coherenceMetrics = computeCoherenceMetrics(
+      candidates,
+      DEFAULT_COHERENCE_THRESHOLD,
+      expectedAllowlist
+    );
+    const markedIncomparable = !coherenceMetrics.isCoherent;
+    const warnings = [];
+    if (markedIncomparable) {
+      warnings.push(
+        `Low coherence between successful candidates (avg ${coherenceMetrics.averageSimilarity.toFixed(2)} < ${coherenceMetrics.coherenceThreshold.toFixed(2)})`
+      );
+    }
+    if (aiJudgeError) {
+      warnings.push(`AI judge invocation failed: ${aiJudgeError}`);
+    }
+    if (winnerInfo.noWinnerDiagnostic) {
+      warnings.push(winnerInfo.noWinnerDiagnostic);
+    }
+    warnings.push(...matrixAuthorityWarnings);
+    if (winnerInfo.belowThresholdWinner) {
+      warnings.push(
+        `Winner selected below threshold (${winnerInfo.belowThresholdWinner.winnerScore} < ${winnerInfo.belowThresholdWinner.threshold})`
+      );
+    }
+    const driftContext = computeCompetitionDrift(candidates, expectedAllowlist, effectiveMode);
+    try {
+      await artifactStore.save(stage.id, "stage-change", "json", {
+        stageId: stage.id,
+        stageType: "competition",
+        mode: effectiveMode,
+        deliveredFiles: driftContext.deliveredFiles,
+        expectedFiles: driftContext.expectedFiles,
+        violations: driftContext.violations,
+        hasDrift: driftContext.hasDrift,
+        candidateCount: candidates.length,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      await artifactStore.save(stage.id, "stage-change-summary", "text", driftContext.summary);
+    } catch (error) {
+      if (options.verbose) {
+        console.warn(chalk.yellow(`   Warning: Failed to persist drift context: ${error}`));
+      }
+    }
+    const effectiveWinnerInfo = winnerInfo;
+    const winnerTestsNotApplicable = effectiveWinnerInfo.winner !== null && winnerHasNoApplicableTests(effectiveWinnerInfo.winner) && candidateGatePassedVariantIds.has(variantIdForSpec(effectiveWinnerInfo.winner.variant));
+    const winnerTrustedTestStatus = effectiveWinnerInfo.winner ? resolveTrustedCandidateTestStatus(effectiveWinnerInfo.winner) : void 0;
+    const winnerRepairSuperseded = winnerTrustedTestStatus !== effectiveWinnerInfo.winner?.testStatus;
+    const winnerVerificationAllowsSuccess = effectiveWinnerInfo.winner ? verificationPolarityAllowsStageSuccess({
+      verification: effectiveWinnerInfo.winner.verification,
+      testStatus: winnerTestsNotApplicable ? void 0 : winnerTrustedTestStatus,
+      rawTestStatus: winnerTestsNotApplicable ? void 0 : winnerTrustedTestStatus,
+      // The stale pre-repair exit code restates the superseded failure.
+      exitCode: winnerTestsNotApplicable || winnerRepairSuperseded ? void 0 : effectiveWinnerInfo.winner.testsExecuted?.exitCode
+    }) : false;
+    const validationPassed = successCount > 0 && effectiveWinnerInfo.winner !== null && winnerVerificationAllowsSuccess;
+    let summary = buildCompetitionSummary(candidates, effectiveWinnerInfo, config);
+    if (aiJudgeError && shouldInvokeAiJudge) {
+      summary = `Competition failed: AI judge invocation failed: ${aiJudgeError}`;
+    }
+    if (markedIncomparable) {
+      summary += ` (low coherence: ${coherenceMetrics.averageSimilarity.toFixed(2)})`;
+    }
+    const scoringMode = aiJudgeInvoked ? "ai-judge" : tieBreakAiJudgeInvoked ? "hybrid" : "deterministic";
+    const judgeInvocationReason = aiJudgeError ? "error" : tieBreakAiJudgeInvoked || aiJudgeInvoked ? "multiple-successful-candidates" : successCount === 0 ? "no-successful-candidates" : successCount === 1 ? "single-successful-candidate" : "deterministic-shortcut";
+    const winnerNeedsRepair = Boolean(
+      effectiveWinnerInfo.winner?.verification && !effectiveWinnerInfo.winner.verification.passed
+    );
+    const stageVerification = effectiveWinnerInfo.winner?.verification;
+    const result = {
+      stageId: stage.id,
+      stageType: "competition",
+      competitionTaskId: taskId,
+      validationPassed,
+      validationScore: effectiveWinnerInfo.winner?.score,
+      cost: totalCost,
+      costUnavailableReason,
+      warnings: warnings.length > 0 ? warnings : void 0,
+      summary,
+      durationMs: Date.now() - startTime,
+      candidates,
+      winner: effectiveWinnerInfo.winner,
+      winnerApplied: false,
+      // MVP: winner application happens in the workflow executor
+      winnerNeedsRepair,
+      verification: stageVerification,
+      coherenceMetrics,
+      markedIncomparable,
+      scoringMode,
+      competitionJudgeResult: {
+        judgeType: config.judgeConfig?.type ?? "ai",
+        aiJudgeAttempted,
+        aiJudgeInvoked: tieBreakAiJudgeInvoked || aiJudgeInvoked,
+        aiJudgeError,
+        aiJudgeProviderFailed: judgeProviderFailed(latestMainJudgeResult?.decision) || void 0,
+        judgeInvocationReason,
+        rankings: effectiveWinnerInfo.rankings,
+        wasTie: effectiveWinnerInfo.wasTie,
+        noWinnerReason: effectiveWinnerInfo.noWinnerReason,
+        belowThresholdWinner: effectiveWinnerInfo.belowThresholdWinner,
+        tieBreaker: effectiveWinnerInfo.tieBreaker,
+        scoreCollisionReport: effectiveWinnerInfo.scoreCollisionReport
+      },
+      driftContext
+    };
+    if (!validationPassed && effectiveWinnerInfo.winner && successCount > 0 && !aiJudgeError) {
+      const refusal = resolveWinnerDeliveryRefusalReason(result);
+      if (refusal) result.summary = `${summary}; winner not accepted: ${refusal}`;
+    }
+    if (options.verbose) {
+      console.log(chalk.green("   ok Competition complete"));
+      console.log(
+        chalk.gray(
+          `   Winner: ${effectiveWinnerInfo.winner ? formatCompetitionCandidateVariantDisplay(effectiveWinnerInfo.winner) : "none"}`
+        )
+      );
+      console.log(
+        chalk.gray(
+          `   Total cost: ${costUnavailableReason !== void 0 ? "unavailable" : `$${totalCost.toFixed(4)}`}`
+        )
+      );
+      console.log(
+        chalk.gray(
+          `   Coherence: ${coherenceMetrics.averageSimilarity.toFixed(2)} (${coherenceMetrics.isCoherent ? "coherent" : "INCOHERENT"})`
+        )
+      );
+      if (driftContext.hasDrift) {
+        console.log(
+          chalk.yellow(
+            `   Drift: ${driftContext.violations.length} file(s) outside allowlist (mode: ${effectiveMode})`
+          )
+        );
+      }
+    }
+    const authoritativeWinner = effectiveWinnerInfo.winner ? matchVariantResult(effectiveWinnerInfo.winner.variant, basicResult.variants) : void 0;
+    if (effectiveWinnerInfo.winner && !authoritativeWinner) {
+      const errorMessage = "Final competition winner could not be resolved to an executed variant";
+      await finalizeDeferredHandle(
+        createEvaluationHandleFinalState({ outcome: "error", winner: null, errorMessage })
+      );
+      await cleanupSynthesisInputPatches(basicResult.variants, {
+        expectedRoot: resolveSynthesisInputPatchDir(
+          competitionOptions.executionContext.buildDir,
+          taskId
+        )
+      });
+      throw new Error(errorMessage);
+    }
+    await finalizeDeferredHandle(
+      authoritativeWinner ? createEvaluationHandleFinalState({
+        outcome: "winner_selected",
+        winner: toEvaluationHandleWinnerMetadata(authoritativeWinner)
+      }) : createEvaluationHandleFinalState({
+        outcome: successCount === 0 ? "all_failed" : "no_winner",
+        winner: null
+      })
+    );
+    await cleanupSynthesisInputPatches(basicResult.variants, {
+      expectedRoot: resolveSynthesisInputPatchDir(
+        competitionOptions.executionContext.buildDir,
+        taskId
+      )
+    });
+    return result;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (!deferredHandleFinalized) {
+      await finalizeEvaluationHandleAsync(
+        taskId,
+        createEvaluationHandleFinalState({ outcome: "error", winner: null, errorMessage })
+      ).catch(() => {
+      });
+    }
+    await cleanupSynthesisInputPatches(basicResult.variants, {
+      expectedRoot: resolveSynthesisInputPatchDir(
+        competitionOptions.executionContext.buildDir,
+        taskId
+      )
+    }).catch(() => {
+    });
+    return {
+      stageId: stage.id,
+      stageType: "competition",
+      competitionTaskId: taskId,
+      validationPassed: false,
+      ...observedCandidates ? resolveCompetitionCostAggregate(observedCandidates) : { cost: 0, costUnavailableReason: "provider_not_reported" },
+      candidates: observedCandidates ?? [],
+      winner: null,
+      summary: `Competition post-processing failed: ${errorMessage}`,
+      durationMs: Date.now() - startTime,
+      competitionJudgeResult: {
+        judgeType: config.judgeConfig?.type ?? "ai",
+        aiJudgeAttempted,
+        aiJudgeInvoked: tieBreakAiJudgeInvoked || aiJudgeInvoked,
+        aiJudgeError: errorMessage,
+        judgeInvocationReason: "error",
+        rankings: [],
+        wasTie: false,
+        noWinnerReason: "judge-error"
+      }
+    };
+  }
+}
+function buildCompetitionSummary(candidates, winnerInfo, config) {
+  const successCount = candidates.filter((c) => c.success).length;
+  const failCount = candidates.length - successCount;
+  let summary = `Competition: ${successCount}/${candidates.length} variants succeeded`;
+  if (failCount > 0) {
+    summary += ` (${failCount} failed)`;
+  }
+  if (winnerInfo.winner) {
+    summary += `. ${competitionPickLabel(successCount)}: ${formatCompetitionCandidateVariantDisplay(winnerInfo.winner)}`;
+    if (winnerInfo.winner.score !== void 0) {
+      summary += ` (score: ${winnerInfo.winner.score})`;
+    }
+    if (winnerInfo.belowThresholdWinner) {
+      summary += ` (below threshold: ${winnerInfo.belowThresholdWinner.winnerScore} < ${winnerInfo.belowThresholdWinner.threshold})`;
+    }
+  } else if (winnerInfo.noWinnerReason) {
+    const reasons = {
+      "all-failed": "all variants failed",
+      tie: "tie between top variants",
+      "below-threshold": `all scores below threshold (${config.judgeConfig?.threshold ?? 0})`,
+      "judge-error": "judge evaluation failed",
+      incomparable: "candidates touched disjoint files (low coherence)"
+    };
+    summary += `. No winner: ${reasons[winnerInfo.noWinnerReason] ?? winnerInfo.noWinnerReason}`;
+  }
+  return summary;
+}
+function isCompetitionStage(stage) {
+  return stage.type === "competition" && stage.competition !== void 0;
+}
+
+export {
+  selectFailingGateFindings,
+  gateEvidenceField,
+  persistGateEvidenceArtifact,
+  verificationPolarityAllowsStageSuccess,
+  describeStageValidationFailure,
+  resolveWinnerDeliveryRefusalReason,
+  shouldRestrictWinnerPatchToAllowlist,
+  applyCompetitionWinnerPatch,
+  computeCoherenceMetrics,
+  __internalDetermineWinner,
+  __internalRecordDeterministicTestSignalObservation,
+  __internalExtractChangedFilesFromResult,
+  __internalGetVariantTelemetryStatePath,
+  __internalHydrateCandidateCostsFromTelemetry,
+  __internalVariantResultToCandidate,
+  __internalMatchVariantResult,
+  __internalCandidateMatchesVariantResult,
+  __internalResolveCompetitionCostAggregate,
+  executeCompetitionStage,
+  isCompetitionStage
+};
+//# sourceMappingURL=chunk-3NOTLVLG.js.map