@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-QP4UTSOV.js

@@ -0,0 +1,3587 @@
+import {
+  parseCitationTrace,
+  serializeCitationTrace
+} from "./chunk-OSK7QWPD.js";
+import {
+  classifyWinnerSelectionSource,
+  formatAnalysisSynthesisArtifactPath,
+  formatAnalysisSynthesisPathLine,
+  formatVariantKeyForDisplay,
+  getCanonicalVariantKeyFromResult,
+  getDisplayVerificationVerdict,
+  getTop2FromSynthesis,
+  inferDecisionOutcome,
+  inferDecisionStatus,
+  isCompletedVariant,
+  isNearTieMargin,
+  isVerifiedVariant,
+  isWinnerVerifiedForGatePolicy,
+  resolveJudgeTop2,
+  runAnalysisSynthesis,
+  runAnalysisSynthesisProvider,
+  sanitizeAnalysisSynthesisContributorError,
+  shouldRunAnalysisSynthesisStage,
+  stripPreambleBeforeFirstHeading,
+  summarizeFusionSections,
+  variantHandlesMatchForResults
+} from "./chunk-LWGKN2GY.js";
+import {
+  isValidationTargetedCodeOverrideExpected
+} from "./chunk-3PL22IYZ.js";
+import {
+  recordCompetitionOutcomeEvent,
+  resolveLatestEvaluationId
+} from "./chunk-TSQ256N5.js";
+import {
+  buildCompetitionOutcomeEvent,
+  persistCompetitionOutcomeEvent
+} from "./chunk-YBHUB4XR.js";
+import {
+  updateEvaluationHandleApplicationProvenance
+} from "./chunk-NTD6CSI6.js";
+import {
+  formatTokens,
+  normalizeProviderRunDiagnostics,
+  providerDiagnosticsReportFatalRuntimeIssue
+} from "./chunk-MW2DWWVA.js";
+import {
+  detectHostConcurrencyBudget
+} from "./chunk-BZRLSZNV.js";
+import {
+  formatDurationMs
+} from "./chunk-2L36U25O.js";
+import {
+  isFailoverEnabled
+} from "./chunk-SBBNT5ZJ.js";
+import {
+  classifyProviderResultFailure,
+  printProviderSwitchNotice,
+  runWithProviderFailover
+} from "./chunk-VLMDM56Q.js";
+import {
+  applyVariantLabelsToScores,
+  computeEscalation,
+  extractJudgeConsistencyTelemetry,
+  extractJudgeUsageSummary,
+  extractPromptTelemetrySummaryFromAudit,
+  extractVariantLabelMappingFromAudit,
+  formatJudgeCandidateId,
+  hasIgnoredPlanningArtifactEvidence,
+  isVerificationIntegrityReason
+} from "./chunk-DCACX7BV.js";
+import {
+  computeFinalScore
+} from "./chunk-JOSK6GEU.js";
+import {
+  registry
+} from "./chunk-7HYBSRPZ.js";
+import {
+  withoutNegatedSpans
+} from "./chunk-LDJCKAJP.js";
+import {
+  classifyNoWorkFailure
+} from "./chunk-PRDHI2L5.js";
+import {
+  infoEvent
+} from "./chunk-GQXLXRFA.js";
+import {
+  classifyExplicitNoEdit,
+  detectProseResponseOnlyDirective
+} from "./chunk-PPHXX4W7.js";
+import {
+  ConfigManager
+} from "./chunk-W4BAIQ6L.js";
+import {
+  sanitizeDiagnosticOutput
+} from "./chunk-RBKLOUXA.js";
+import {
+  resolveCandidates,
+  resolvePreferred,
+  resolveSynthesisReasoningEffort
+} from "./chunk-C3DH3NCY.js";
+import {
+  formatDurationSeconds
+} from "./chunk-FRBPKBFE.js";
+import {
+  filterWorktreeRunSentinelStatusOutput
+} from "./chunk-2NMNFUQA.js";
+import {
+  parseSynthesisModelTarget
+} from "./chunk-I7SCBHJN.js";
+import {
+  formatVariantIdentifierFromResult
+} from "./chunk-TGXXYDL4.js";
+import {
+  atomicWriteJson
+} from "./chunk-RFDVSI4N.js";
+import {
+  formatPostApplyUnverifiedLabel,
+  judgeWinnerLine,
+  resolveBranchApplyBoundary,
+  resolveEffectiveCompletionMode
+} from "./chunk-SKTFRFQ7.js";
+import {
+  deriveVariantOutcome,
+  hasVetoingUnavailableVerificationGateEvidence,
+  isIgnoredPlanningArtifactPath,
+  readVariantVerification
+} from "./chunk-3OPP2OZB.js";
+import {
+  extractScopedSourceFiles,
+  hasExplicitFileTargets
+} from "./chunk-KUEWV2JH.js";
+import {
+  assertCompeteProtectedBranchForCompletionMode,
+  classifyBranchRole,
+  getCurrentBranch,
+  isDisposableBranchRole,
+  needsNewWorkingBranch
+} from "./chunk-XGU6PBO5.js";
+import {
+  taskVariantId
+} from "./chunk-F55YABKV.js";
+import {
+  getProjectReferencePathExtensions
+} from "./chunk-RPIMAMV7.js";
+import {
+  toVariantSlug
+} from "./chunk-2VLJUXJU.js";
+import {
+  LabPathResolver
+} from "./chunk-C3KCMAJP.js";
+import {
+  resolveLabsRoot
+} from "./chunk-AJN5Y5YZ.js";
+import {
+  redactSynthesisDeliverableSecrets,
+  sanitizeSynthesisArtifactForPersistence,
+  sanitizeSynthesisStringForPersistence
+} from "./chunk-VSWC5ZXI.js";
+import {
+  normalizeEngineId
+} from "./chunk-KKQKWAMF.js";
+import {
+  rethrowConfigValidityError
+} from "./chunk-QJ6OEH4K.js";
+import {
+  emitCustomWarning,
+  emitWarning,
+  getExecutionContext,
+  hasExecutionContext,
+  resolveBuildDirFromContext
+} from "./chunk-7VRJHTGZ.js";
+
+// src/cli/competition-interruption.ts
+function shouldStopBeforeJudgeOrSynthesis(isShuttingDown, variants) {
+  return isShuttingDown || variants.some((variant) => variant.terminationReason === "canceled_user");
+}
+
+// src/cli/handlers/compete/compete-finalize.ts
+import * as fs2 from "fs/promises";
+import * as path3 from "path";
+
+// src/core/compete/completion-eligibility.ts
+function verificationLabel(winnerVerified) {
+  return winnerVerified === void 0 ? "has unknown verification status" : "is unverified";
+}
+function resolveCompletionEligibility(input) {
+  const sideEffecting = input.effectiveCompletionMode === "pr" || input.effectiveCompletionMode === "branch";
+  if (!sideEffecting) {
+    return { action: "apply-winner", reason: "non-side-effecting completion mode" };
+  }
+  if (input.winnerVerified === true) {
+    return { action: "apply-winner", reason: "winner verified" };
+  }
+  const label = verificationLabel(input.winnerVerified);
+  if (input.verifiedAlternativeLabels.length === 0) {
+    return {
+      action: "refuse",
+      reason: `judge winner ${label} and no verified variant(s) exist`
+    };
+  }
+  const labelList = input.verifiedAlternativeLabels.join(", ");
+  if (input.nearTie) {
+    if (input.hasVerifiedAlternativeForApply) {
+      return {
+        action: "apply-verified-alternative",
+        reason: `judge winner ${label}; substituting verified near-tie alternative`
+      };
+    }
+    return {
+      action: "refuse",
+      reason: `judge winner is provisional/unverified while verified variant(s) exist: ${labelList}`
+    };
+  }
+  return {
+    action: "refuse",
+    reason: `judge winner ${label} while verified variant(s) exist, but the judge preferred the winner by a wide margin (not a near-tie). Refusing to auto-substitute a lower-ranked variant or ship an unverified winner. Inspect the results and apply manually, or re-run. Verified alternative(s): ${labelList}`
+  };
+}
+
+// src/cli/handlers/compete/results-reference.ts
+import * as path from "path";
+function resolveHandoffPathFromStatePath(statePath) {
+  return statePath.endsWith(".json") ? statePath.replace(/\.json$/, ".handoff.md") : `${statePath}.handoff.md`;
+}
+function buildPortableResultsCommand(input) {
+  const resultsCommand = input.surface === "fusion" ? `run fusion results ${input.taskId}` : `run competition results ${input.taskId}`;
+  const explicitRepoRoot = input.repoRoot?.trim();
+  const contextRepoRoot = hasExecutionContext() ? getExecutionContext().repoRoot : void 0;
+  const repoRoot = (explicitRepoRoot || String(contextRepoRoot ?? "")).trim();
+  if (!repoRoot) {
+    return `build ${resultsCommand}`;
+  }
+  const invoker = resolvePortableResultsInvoker({
+    repoRoot,
+    currentEntryPath: input.currentEntryPath ?? process.argv[1]
+  });
+  return `cd ${quoteReplayArg(repoRoot)} && ${invoker} ${resultsCommand}`;
+}
+function buildMatrixEvaluationCommand(input) {
+  const labArgs = input.labContext ? ` --lab-id ${quoteReplayArg(input.labContext.labId)} --run-id ${quoteReplayArg(input.labContext.runId)}` : "";
+  return `build judge evaluate ${quoteReplayArg(input.taskId)}${labArgs} --judge-profile matrix --json`;
+}
+function resolvePortableResultsInvoker(input) {
+  const currentEntryPath = input.currentEntryPath?.trim();
+  if (!currentEntryPath) {
+    return "build";
+  }
+  const repoRoot = path.resolve(input.repoRoot);
+  const entryPath = path.resolve(currentEntryPath);
+  const relativeEntryPath = path.relative(repoRoot, entryPath);
+  if (relativeEntryPath === path.join("dist", "entry.js")) {
+    return `node ${quoteReplayArg(relativeEntryPath)}`;
+  }
+  return "build";
+}
+function quoteReplayArg(value) {
+  if (/^[A-Za-z0-9_./:=,+@%-]+$/.test(value)) return value;
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+// src/cli/handlers/compete/competition-judge-shared.ts
+function classifyJudgeFailureMessage(message) {
+  if (!message || message.trim().length === 0) return "inconclusive";
+  const normalized = message.trim();
+  if (/sandbox|reason=sandbox|policy blocked|EPERM|Operation not permitted|readonly profile requires/i.test(
+    normalized
+  )) {
+    return "sandbox";
+  }
+  if (/\btimeout\b/i.test(normalized)) return "timeout";
+  if (/parse failure|validation failure|malformed_json|invalid_output/i.test(normalized)) {
+    return "invalid_output";
+  }
+  return "error";
+}
+function formatHeuristicFallbackGuidance() {
+  return "Use --allow-heuristic-fallback (or BUILD_ALLOW_HEURISTIC_FALLBACK=1) to promote a heuristic or secondary-judge winner.";
+}
+function formatJudgeSkippedWarning(variantCount) {
+  return variantCount === 0 ? "AI judge skipped because no safely attributable canonical variant keys were available." : "No variant produced output; skipping the judge. There is no winner.";
+}
+function formatJudgeNoWinnerWarning(input) {
+  if (input.kind === "no_declaration") {
+    if (input.allowHeuristicFallback || input.basicMode) {
+      return "AI judge did not return a winner in basic mode; no winner selected.";
+    }
+    return `AI judge did not return a winner; no winner selected. ${formatHeuristicFallbackGuidance()}`;
+  }
+  const failureClass = classifyJudgeFailureMessage(input.message);
+  const detail = failureClass === "sandbox" ? "sandbox blocked judge provider write access" : input.message?.replace(/\s+/g, " ").trim();
+  const detailSuffix = detail ? ` (${detail})` : "";
+  if (input.allowHeuristicFallback && input.basicMode) {
+    return `AI judge evaluation failed in basic mode; no winner selected${detailSuffix}.`;
+  }
+  if (input.allowHeuristicFallback) {
+    return `AI judge evaluation failed; no winner selected${detailSuffix}.`;
+  }
+  const prefix = failureClass === "sandbox" ? "AI judge unavailable (sandbox blocked provider write access)" : "AI judge evaluation failed";
+  return `${prefix}; no winner selected${detailSuffix}. ${formatHeuristicFallbackGuidance()}`;
+}
+function formatSynthesisOutcomeSummary(input) {
+  if (input.synthesisApplied === true) {
+    return {
+      status: "applied",
+      winnerPreserved: true,
+      humanLine: "Validated synthesis delivery; judged winner preserved as base."
+    };
+  }
+  if (input.winnerFallback === true) {
+    const reason = input.fallbackReason ?? "judged winner retained without donor changes";
+    return {
+      status: "winner_fallback",
+      winnerPreserved: true,
+      humanLine: `Synthesis did not apply; winner preserved (${reason}).`
+    };
+  }
+  if (input.error || input.fallbackReason) {
+    const reason = input.error ?? input.fallbackReason ?? "synthesis failed";
+    const winnerPreserved = input.hasWinner !== false;
+    return {
+      status: "rejected",
+      winnerPreserved,
+      humanLine: winnerPreserved ? `Synthesis failed; judged winner preserved (${reason}).` : `Synthesis failed; no winner preserved (${reason}).`
+    };
+  }
+  return {
+    status: "failed",
+    winnerPreserved: input.hasWinner !== false,
+    humanLine: input.hasWinner === false ? "Synthesis not applied; no judged winner to preserve." : "Synthesis not applied; judged winner unchanged."
+  };
+}
+function formatCompetitionApplyNextSteps(taskId, branch) {
+  return [
+    `Competition ID: ${taskId}`,
+    ...needsNewWorkingBranch(branch) ? ["Next: git checkout -b fix/<slug>"] : [],
+    `Next: build run competition apply ${taskId}`
+  ];
+}
+function formatSynthesisFailureNextSteps(taskId) {
+  const resultsCommand = buildPortableResultsCommand({ taskId });
+  return [
+    `Inspect synthesis details: ${resultsCommand}`,
+    `Apply judged winner: git checkout -b fix/<slug> && build run competition apply ${taskId}`
+  ];
+}
+function buildCompeteRunMetadata(input) {
+  return {
+    runSemantics: input.runSemantics,
+    judge: {
+      requested: input.judgeRequested,
+      status: input.judgeStatus,
+      reason: input.judgeReason
+    },
+    research: {
+      requested: input.researchRequested,
+      enabled: input.researchEnabled,
+      skipReason: input.researchEnabled ? void 0 : input.researchSkipReason,
+      mode: input.researchMode,
+      packetPath: input.researchPacketPath,
+      excludedDomains: input.researchExcludeDomain
+    },
+    synthesis: input.synthesisExpected !== void 0 || input.synthesisStatus !== void 0 || input.synthesisArtifactPath !== void 0 || input.synthesisJsonPath !== void 0 || input.synthesisContributorCount !== void 0 ? {
+      expected: input.synthesisExpected,
+      status: input.synthesisStatus,
+      artifactPath: input.synthesisArtifactPath,
+      jsonPath: input.synthesisJsonPath,
+      contributorCount: input.synthesisContributorCount
+    } : void 0,
+    matrix: input.matrixResult ? {
+      autoRun: true,
+      evaluatorType: input.matrixResult.matrixEvaluatorType,
+      profiles: Object.fromEntries(
+        input.matrixResult.profileVerdicts.map((verdict) => [
+          verdict.profile,
+          formatVariantKeyForDisplay(verdict.winner)
+        ])
+      ),
+      winnerStatus: input.matrixResult.winnerStatus ?? "accepted",
+      winnerCaveats: input.matrixResult.winnerCaveats,
+      profilesDisagree: input.matrixResult.disagreements.profilesDisagree,
+      profileDecision: formatMatrixProfileDecision(input.matrixResult),
+      escalationReasons: input.matrixEscalationReasons
+    } : void 0,
+    replay: input.replayCommand || input.replayArgv || input.taskLabel || input.executionIntent ? {
+      command: input.replayCommand,
+      argv: input.replayArgv,
+      taskLabel: input.taskLabel,
+      executionIntent: input.executionIntent
+    } : void 0,
+    lab: {
+      enabled: Boolean(input.labContext),
+      labId: input.labContext?.labId,
+      runId: input.labContext?.runId,
+      baseline: input.labContext?.baseline
+    }
+  };
+}
+function resolvePersistedJudgeRunState(input) {
+  if (input.isFusionRun) return { status: "skipped", reason: "fusion_no_judge" };
+  if (input.judgeOff) return { status: "disabled", reason: "judge_off" };
+  if (!input.aiJudgeRequested) return { status: "skipped" };
+  if (input.winnerSelectionSource === "algorithmic") {
+    return {
+      status: "skipped",
+      reason: input.winnerSelectionReason ?? input.decisionReason ?? "judge_not_run"
+    };
+  }
+  if (input.decisionOutcome === "winner_declared") return { status: "completed" };
+  if (classifyWinnerSelectionSource(input.winnerSelectionSource).isJudgeDerived) {
+    return { status: "completed" };
+  }
+  return {
+    status: "failed",
+    reason: input.decisionReason ?? input.decisionOutcome ?? "judge_no_winner"
+  };
+}
+function resolveWinnerVerifiedForDecision(input) {
+  if (!input.winner || !input.verificationApplicable) return void 0;
+  return isWinnerVerifiedForGatePolicy(
+    input.winner,
+    input.verifiedVariants,
+    input.requiredGatePolicy
+  );
+}
+function formatMatrixProfileWinners(matrixResult) {
+  return matrixResult.profileVerdicts.map((verdict) => `${verdict.profile}=${formatVariantKeyForDisplay(verdict.winner)}`).join(", ");
+}
+function formatMatrixProfileDecision(matrixResult) {
+  if (matrixResult.winnerStatus === "inconclusive") return "inconclusive";
+  return matrixResult.disagreements.profilesDisagree ? "split" : "unanimous";
+}
+function isJudgeType(value) {
+  return value === "ai" || value === "multi-lens";
+}
+function resolveMatrixDefaultWinnerSource(input) {
+  if (isJudgeType(input.synthesisJudgeContext?.selectedJudge)) {
+    return input.synthesisJudgeContext.selectedJudge;
+  }
+  return input.requestedPrimary ?? "ai";
+}
+function hasExecutedTestProvenance(variant) {
+  return variant.testsExecuted !== void 0 && variant.testsExecuted.scope !== "none";
+}
+function hasUnavailableTestProvenance(variant) {
+  return variant.testsExecuted?.scope === "none" && variant.testsExecuted.skipReason === "verification-unavailable";
+}
+function hasExecutedTestResult(variant) {
+  if (variant.testStatus === "passed" || variant.testStatus === "failed") return true;
+  if (variant.testStatus === "timeout") return true;
+  if ((variant.testMetrics?.failedTests ?? 0) > 0) return true;
+  return false;
+}
+function mergeJudgeEvaluatedVariantSignals(targetVariants, evaluatedVariants) {
+  if (!evaluatedVariants?.length) return;
+  const evaluatedByKey = /* @__PURE__ */ new Map();
+  for (const evaluated of evaluatedVariants) {
+    evaluatedByKey.set(formatJudgeCandidateId(evaluated), evaluated);
+  }
+  for (const target of targetVariants) {
+    const source = evaluatedByKey.get(formatJudgeCandidateId(target));
+    if (!source) continue;
+    if (source.acceptedWorkspaceTreeSha !== void 0)
+      target.acceptedWorkspaceTreeSha = source.acceptedWorkspaceTreeSha;
+    const unavailable = source.testsExecuted;
+    if (unavailable && hasUnavailableTestProvenance(source)) {
+      if (hasExecutedTestResult(target)) continue;
+      target.testStatus = "not_run";
+      target.testMetrics = void 0;
+      target.testsExecuted = {
+        ...unavailable,
+        filesTested: [...unavailable.filesTested]
+      };
+      target.outcome = deriveVariantOutcome(target);
+      continue;
+    }
+    if (!hasExecutedTestProvenance(source)) continue;
+    target.testStatus = source.testStatus;
+    if (source.testMetrics) {
+      target.testMetrics = { ...source.testMetrics };
+    }
+    if (source.testsExecuted) {
+      target.testsExecuted = {
+        ...source.testsExecuted,
+        filesTested: [...source.testsExecuted.filesTested]
+      };
+      if (source.testsExecuted.sourceFiles) {
+        target.testsExecuted.sourceFiles = [...source.testsExecuted.sourceFiles];
+      }
+    }
+    target.outcome = deriveVariantOutcome(target);
+  }
+}
+function judgeVerificationStatePatch(variant) {
+  return {
+    ...variant.acceptedWorkspaceTreeSha !== void 0 ? { acceptedWorkspaceTreeSha: variant.acceptedWorkspaceTreeSha } : {},
+    ...variant.outcome ? { outcome: variant.outcome } : {},
+    ...variant.testStatus ? { testStatus: variant.testStatus } : {},
+    ...variant.testMetrics ? { testMetrics: variant.testMetrics } : {},
+    ...variant.testsExecuted ? { testsExecuted: variant.testsExecuted } : {}
+  };
+}
+var SYNTHESIS_TARGET_TEXT_MAX_CHARS = 400;
+var SYNTHESIS_TARGET_EVIDENCE_MAX_ITEMS = 4;
+var SYNTHESIS_TARGET_EVIDENCE_ITEM_MAX_CHARS = 300;
+function boundSynthesisAdvisoryText(value, maxChars = SYNTHESIS_TARGET_TEXT_MAX_CHARS) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxChars) return normalized;
+  return `${normalized.slice(0, Math.max(0, maxChars - 1)).trimEnd()}\u2026`;
+}
+function boundSynthesisAdvisoryEvidence(evidence) {
+  return evidence.slice(0, SYNTHESIS_TARGET_EVIDENCE_MAX_ITEMS).map((item) => boundSynthesisAdvisoryText(item, SYNTHESIS_TARGET_EVIDENCE_ITEM_MAX_CHARS)).filter((item) => item.length > 0);
+}
+function deriveTargetedCriterionGap(matrixResult, selectedWinnerId) {
+  const assessments = matrixResult.criterionAssessments;
+  const advantages = matrixResult.runnerUpAdvantages;
+  if (!assessments || !advantages) return void 0;
+  const winnerGaps = assessments.filter(
+    (assessment) => assessment.variant === selectedWinnerId && (assessment.status === "partial" || assessment.status === "missing")
+  );
+  if (winnerGaps.length !== 1) return void 0;
+  const gapAssessment = winnerGaps[0];
+  if (!gapAssessment) return void 0;
+  const gapStatus = gapAssessment.status;
+  if (gapStatus !== "partial" && gapStatus !== "missing") return void 0;
+  const mappedAdvantages = advantages.filter((advantage) => {
+    const gap = advantage.winnerCriterionGap;
+    return gap != null && gap.variant === selectedWinnerId && gap.criterionId === gapAssessment.criterionId;
+  });
+  if (mappedAdvantages.length !== 1) return void 0;
+  const donorAdvantage = mappedAdvantages[0];
+  if (!donorAdvantage) return void 0;
+  const disposition = donorAdvantage.disposition;
+  if (disposition !== "adopt" && disposition !== "harvest") return void 0;
+  if (donorAdvantage.sourceVariant === selectedWinnerId) return void 0;
+  return {
+    criterionId: gapAssessment.criterionId,
+    status: gapStatus,
+    criterionEvidence: boundSynthesisAdvisoryEvidence(gapAssessment.evidence),
+    donorVariantId: donorAdvantage.sourceVariant,
+    disposition,
+    advantage: boundSynthesisAdvisoryText(donorAdvantage.advantage),
+    donorEvidence: boundSynthesisAdvisoryEvidence(donorAdvantage.evidence)
+  };
+}
+function buildSynthesisMatrixAdvisory(matrixResult, selectedWinnerId) {
+  if (!matrixResult || matrixResult.profileVerdicts.length === 0) return void 0;
+  const targetedCriterionGap = selectedWinnerId && selectedWinnerId.trim().length > 0 ? deriveTargetedCriterionGap(matrixResult, selectedWinnerId) : void 0;
+  return {
+    evaluatorType: matrixResult.matrixEvaluatorType,
+    winnerStatus: matrixResult.winnerStatus,
+    profileDecision: formatMatrixProfileDecision(matrixResult),
+    profilesDisagree: matrixResult.disagreements.profilesDisagree,
+    profileVerdicts: matrixResult.profileVerdicts.slice(0, 6).map((verdict) => ({
+      profile: verdict.profile,
+      winner: verdict.winner,
+      rationale: verdict.rationale
+    })),
+    winnerCaveats: matrixResult.winnerCaveats?.slice(0, 5),
+    blockingHumanChecks: matrixResult.diagnostics.blockingHumanChecks.slice(0, 5),
+    advisoryHumanChecks: matrixResult.diagnostics.advisoryHumanChecks.slice(0, 5),
+    ...targetedCriterionGap ? { targetedCriterionGap } : {}
+  };
+}
+function attachMatrixAdvisoryToSynthesisContext(judgeContext, matrixResult, selectedWinnerId) {
+  const advisoryMatrix = buildSynthesisMatrixAdvisory(matrixResult, selectedWinnerId);
+  if (!advisoryMatrix) return judgeContext;
+  if (!judgeContext) return void 0;
+  return {
+    ...judgeContext,
+    advisoryMatrix
+  };
+}
+function isLowConfidenceBaselineReason(reason) {
+  return Boolean(reason?.includes("low_confidence") && reason.includes("baseline_"));
+}
+function resolveEffectiveJudgeDecision(input) {
+  const judgeExecutionFailed = input.judgeExecutionFailed === true || isJudgeUnavailableDecision(input.latestDecision);
+  const winnerSynthesis = input.winner?.judgeEvaluation;
+  const top2 = winnerSynthesis ? resolveJudgeTop2(winnerSynthesis, input.latestDecision) : void 0;
+  const inferredStatus = inferDecisionStatus({
+    winnerSelectionReason: input.winner?.winnerSelectionReason,
+    margin: top2?.margin ?? input.latestDecision?.margin ?? null,
+    threshold: input.latestDecision?.closeCallThreshold ?? null
+  });
+  const decisionStatus = input.latestDecision?.decisionStatus === "declared" && (inferredStatus === "close_call" || inferredStatus === "low_confidence") ? inferredStatus : input.latestDecision?.decisionStatus ?? inferredStatus;
+  const inferredEscalation = computeEscalation({
+    decisionStatus,
+    winner: input.winner ?? void 0,
+    margin: top2?.margin ?? input.latestDecision?.margin ?? null,
+    winnerConfidence: typeof winnerSynthesis?.metadata?.confidence === "number" ? winnerSynthesis.metadata.confidence : null,
+    matrixEscalationThresholds: input.latestDecision?.matrixEscalationThresholds,
+    requiredGatePolicy: input.requiredGatePolicy,
+    judgeExecutionFailed
+  });
+  const coordinatorEscalation = input.latestDecision?.escalation;
+  if (coordinatorEscalation?.matrixSkipped || coordinatorEscalation?.judgeExecutionFailed) {
+    return { decisionStatus, escalation: coordinatorEscalation };
+  }
+  if (judgeExecutionFailed) {
+    return { decisionStatus, escalation: inferredEscalation };
+  }
+  const selectedEscalation = coordinatorEscalation && coordinatorEscalation.recommended !== "none" ? reconcileEscalationWithPolicy(coordinatorEscalation, inferredEscalation) : inferredEscalation;
+  return { decisionStatus, escalation: selectedEscalation };
+}
+function reconcileEscalationWithPolicy(coordinatorEscalation, inferredEscalation) {
+  const policyIntegrityReasons = new Set(inferredEscalation.integrityReasons);
+  const coordinatorReasons = coordinatorEscalation.reasons.filter(
+    (reason) => !isVerificationIntegrityReason(reason) || policyIntegrityReasons.has(reason)
+  );
+  const mergedReasons = [.../* @__PURE__ */ new Set([...coordinatorReasons, ...inferredEscalation.reasons])];
+  if (mergedReasons.length === 0) {
+    return {
+      recommended: "none",
+      reasons: [],
+      humanReviewRecommended: false,
+      integrityReasons: []
+    };
+  }
+  const integrityReasons = mergedReasons.filter(isVerificationIntegrityReason);
+  return {
+    recommended: "matrix",
+    reasons: mergedReasons,
+    humanReviewRecommended: false,
+    integrityReasons
+  };
+}
+function formatMatrixAutoRunReason(decision) {
+  const reasons = decision?.escalation?.reasons ?? [];
+  const margin = typeof decision?.margin === "number" ? decision.margin : void 0;
+  const thresholds = decision?.matrixEscalationThresholds;
+  const detail = [];
+  if (margin !== void 0) {
+    detail.push(`margin ${margin.toFixed(1)}`);
+  }
+  if (thresholds) {
+    detail.push(
+      `close<=${thresholds.closeCallMargin}, borderline<=${thresholds.borderlineMargin}, confidence<${thresholds.confidenceThreshold}`
+    );
+  }
+  if (reasons.length > 0) {
+    detail.push(`reasons: ${reasons.join(",")}`);
+  }
+  return detail.length > 0 ? ` (${detail.join("; ")})` : "";
+}
+function resolveWinnerMethodForDisplay(input) {
+  if (input.lowConfidenceBaseline) return "algorithmic";
+  const info = classifyWinnerSelectionSource(input.source);
+  if (info.isMatrixVerdict) return "matrix-verdict";
+  if (info.isJudgeDerived) {
+    const tier = info.judgeType ?? input.primaryJudge ?? "ai";
+    if (tier === "multi-lens") return "multi-lens";
+    if (tier === "multi-agent") return "multi-agent";
+    return "ai-judge";
+  }
+  if (input.source === "fallback") return "fallback";
+  return "algorithmic";
+}
+function maybePromoteAlgorithmicFallbackWinner(result, fallbackWinner, reason, allowHeuristicFallback) {
+  if (!allowHeuristicFallback) {
+    return false;
+  }
+  return promoteAlgorithmicFallbackWinner(result, fallbackWinner, reason);
+}
+function promoteAlgorithmicFallbackWinner(result, fallbackWinner, reason, source = "fallback") {
+  if (!fallbackWinner) {
+    return false;
+  }
+  fallbackWinner.winnerSelectionSource = source;
+  fallbackWinner.winnerSelectionReason = fallbackWinner.winnerSelectionReason ? `${fallbackWinner.winnerSelectionReason};${reason}` : reason;
+  result.winner = fallbackWinner;
+  result.winnerMethod = source;
+  return true;
+}
+function isJudgeUnavailableDecision(decision) {
+  const reason = typeof decision?.reason === "string" ? decision.reason : typeof decision?.decisionOutcome === "string" ? decision.decisionOutcome : "";
+  const normalized = reason.toLowerCase();
+  return normalized.includes("judge_error") || normalized.includes("timeout") || normalized.includes("abort") || normalized.includes("unavailable");
+}
+function isJudgeInconclusiveDecision(decision) {
+  if (!decision || isJudgeUnavailableDecision(decision)) {
+    return false;
+  }
+  const reason = typeof decision.reason === "string" ? decision.reason : typeof decision.decisionOutcome === "string" ? decision.decisionOutcome : "";
+  return decision.decisionOutcome === "inconclusive" || /\binconclusive\b/i.test(reason) || /\b(llm[-_]?no[-_]?declaration|no_winner|no-winner)\b/i.test(reason);
+}
+function resolveAlgorithmicFallbackWinner(variantsForJudge, heuristicWinner) {
+  if (heuristicWinner && isCompletedVariant(heuristicWinner)) {
+    return heuristicWinner;
+  }
+  if (variantsForJudge.length === 1) {
+    const only = variantsForJudge[0];
+    return only && isCompletedVariant(only) ? only : null;
+  }
+  const completed = variantsForJudge.filter((variant) => isCompletedVariant(variant));
+  if (completed.length === 0) {
+    return null;
+  }
+  if (completed.length === 1) {
+    return completed[0] ?? null;
+  }
+  return completed.sort((a, b) => (b.completeness ?? 0) - (a.completeness ?? 0))[0] ?? null;
+}
+
+// src/cli/handlers/compete/telemetry-winner-verification.ts
+function isWinnerVerifiedByTelemetryResultSet(variants, judgedWinner) {
+  const winnerKey = formatJudgeCandidateId(judgedWinner);
+  const resultSetWinner = variants.find((variant) => formatJudgeCandidateId(variant) === winnerKey);
+  return isVerifiedVariant(resultSetWinner ?? judgedWinner);
+}
+
+// src/cli/handlers/compete/variant-state-file.ts
+import * as fs from "fs/promises";
+import * as path2 from "path";
+var NON_RESULT_SUFFIX = /\.(partial|lifecycle|adaptive-setup)\.json$/;
+function instanceOf(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+async function findVariantStateFile(stateDir, taskId, variant) {
+  const prefix = `${taskId.replace(/[^a-zA-Z0-9-_]/g, "")}-`;
+  let names;
+  try {
+    names = await fs.readdir(stateDir);
+  } catch {
+    return void 0;
+  }
+  const wanted = formatVariantIdentifierFromResult(variant);
+  for (const name of names.filter((n) => n.startsWith(prefix) && n.endsWith(".json")).sort()) {
+    if (NON_RESULT_SUFFIX.test(name)) continue;
+    const filepath = path2.join(stateDir, name);
+    try {
+      const stored = JSON.parse(await fs.readFile(filepath, "utf-8"));
+      if (stored.provider !== variant.provider) continue;
+      if (instanceOf(stored.variantInstanceId) !== instanceOf(variant.variantInstanceId)) continue;
+      if (stored.variant === variant.variant || formatVariantIdentifierFromResult(stored) === wanted) {
+        return filepath;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+
+// src/cli/handlers/compete/compete-finalize.ts
+function buildDeliveryArtifactReference(target, synthesisDeliverySelected) {
+  if (target.artifactManifest) {
+    return {
+      kind: "variant-manifest",
+      identity: target.artifactManifest,
+      variantId: target.variantId,
+      manifestPath: target.artifactManifest,
+      ...target.branchName ? { branch: target.branchName } : {}
+    };
+  }
+  return {
+    kind: synthesisDeliverySelected ? "synthesis-output" : "variant",
+    identity: target.variantId,
+    variantId: target.variantId,
+    ...target.branchName ? { branch: target.branchName } : {}
+  };
+}
+function buildAppliedArtifactReference(event) {
+  const prNumber = typeof event.prNumber === "number" && Number.isFinite(event.prNumber) ? event.prNumber : void 0;
+  if (event.mode === "pr" && prNumber !== void 0) {
+    return {
+      kind: "pull-request",
+      identity: `pr:${prNumber}`,
+      variantId: event.variantId,
+      prNumber,
+      ...event.targetPostApplyHeadSha ? { commitSha: event.targetPostApplyHeadSha } : {},
+      ...event.targetBranch ? { branch: event.targetBranch } : {}
+    };
+  }
+  return {
+    kind: "applied-commit",
+    identity: event.targetPostApplyHeadSha ?? event.sourceHeadSha ?? event.variantId,
+    variantId: event.variantId,
+    ...event.targetPostApplyHeadSha ? { commitSha: event.targetPostApplyHeadSha } : {},
+    ...event.targetBranch ? { branch: event.targetBranch } : {}
+  };
+}
+function buildAppliedCompetitionOutcomeEvent(input) {
+  const occurredAt = input.appliedEvent.appliedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  return buildCompetitionOutcomeEvent({
+    eventType: "completion_applied",
+    competitionId: input.taskId,
+    taskId: input.appliedEvent.taskId ?? input.taskId,
+    occurredAt,
+    ...input.judgeVerdictProduced ? {
+      finalJudgeWinner: {
+        canonicalKey: input.finalJudgeWinner.variantId,
+        ...input.finalJudgeWinner.executionMode ? { executionMode: input.finalJudgeWinner.executionMode } : {}
+      }
+    } : {},
+    deliveryArtifact: buildDeliveryArtifactReference(
+      input.deliveryTarget,
+      input.synthesisDeliverySelected
+    ),
+    ...input.appliedEvent.reason !== "empty_diff" ? { appliedArtifact: buildAppliedArtifactReference(input.appliedEvent) } : {},
+    ...input.appliedEvent.postApplyVerification ? { postApplyVerification: input.appliedEvent.postApplyVerification } : {}
+  });
+}
+async function applyWinnerCompletionMode(params) {
+  const {
+    winnerForApply,
+    onApplicationFact,
+    synthesisDeliveryForApply,
+    verifiedAlternativeForApply,
+    winnerVerified,
+    verifiedAlternativeLabels = [],
+    allowVerifiedAlternativeSubstitution = false,
+    resolvedConfig,
+    options,
+    taskId,
+    branchSnapshot,
+    telemetry,
+    judgeVerdictProduced = false
+  } = params;
+  const { applyCompletionMode } = await import("./apply-completion-mode-EM37UZHB.js");
+  const resolvedCompletionMode = resolvedConfig?.completionMode ?? options.completionMode ?? "auto";
+  const completionModeSource = resolvedConfig?.sources.completionMode ?? (options.completionMode ? "flag" : "built-in");
+  const requestedEffectiveCompletionMode = resolveEffectiveCompletionMode(resolvedCompletionMode, {
+    createPr: options.createPr,
+    winner: { executionMode: winnerForApply.executionMode }
+  });
+  let applyTarget = winnerForApply;
+  let synthesisDeliverySelected = false;
+  let substitutionReason;
+  const synthesisEligibleForDelivery = Boolean(synthesisDeliveryForApply) && synthesisDeliveryForApply?.gatesPassed === true;
+  if (synthesisEligibleForDelivery && synthesisDeliveryForApply) {
+    telemetry.logCustomEvent({
+      event: "completion_mode_synthesis_delivery_selected",
+      completion_mode: requestedEffectiveCompletionMode,
+      task_id: taskId,
+      original_variant_id: winnerForApply.variantId,
+      variant_id: synthesisDeliveryForApply.variantId
+    });
+    applyTarget = synthesisDeliveryForApply;
+    synthesisDeliverySelected = true;
+    substitutionReason = "gate-validated synthesis selected for delivery";
+  } else {
+    const eligibility = resolveCompletionEligibility({
+      effectiveCompletionMode: requestedEffectiveCompletionMode,
+      winnerVerified,
+      verifiedAlternativeLabels,
+      hasVerifiedAlternativeForApply: Boolean(verifiedAlternativeForApply),
+      nearTie: allowVerifiedAlternativeSubstitution
+    });
+    if (eligibility.action === "refuse") {
+      throw new Error(
+        `Refusing completion-mode=${requestedEffectiveCompletionMode}: ${eligibility.reason}`
+      );
+    }
+    if (eligibility.action === "apply-verified-alternative") {
+      if (!verifiedAlternativeForApply) {
+        throw new Error(
+          `Refusing completion-mode=${requestedEffectiveCompletionMode}: judge winner is provisional/unverified while verified variant(s) exist: ${verifiedAlternativeLabels.join(", ")}`
+        );
+      }
+      telemetry.logCustomEvent({
+        event: "completion_mode_verified_alternative_selected",
+        completion_mode: requestedEffectiveCompletionMode,
+        task_id: taskId,
+        original_variant_id: winnerForApply.variantId,
+        variant_id: verifiedAlternativeForApply.variantId,
+        verified_alternatives: verifiedAlternativeLabels
+      });
+      applyTarget = verifiedAlternativeForApply;
+      substitutionReason = eligibility.reason;
+    }
+  }
+  const effectiveCompletionMode = resolveEffectiveCompletionMode(resolvedCompletionMode, {
+    createPr: options.createPr,
+    winner: { executionMode: applyTarget.executionMode }
+  });
+  const applyBoundary = resolveBranchApplyBoundary("compete", options);
+  const applyTargetBranch = effectiveCompletionMode === "branch" ? getCurrentBranch(applyBoundary.projectRoot) : branchSnapshot ?? void 0;
+  if (effectiveCompletionMode === "branch" && branchSnapshot && applyTargetBranch !== branchSnapshot) {
+    throw new Error(
+      `Apply target branch changed before completion-mode apply: expected ${branchSnapshot}, found ${applyTargetBranch}`
+    );
+  }
+  const commingledApply = effectiveCompletionMode === "branch" && Boolean(options.allowCommingleValidationOutput) && applyTargetBranch !== void 0 && isDisposableBranchRole(classifyBranchRole(applyTargetBranch));
+  assertCompeteProtectedBranchForCompletionMode({
+    allowMain: options.allowMain,
+    allowProtected: options.allowProtected,
+    allowCommingleValidationOutput: options.allowCommingleValidationOutput,
+    command: "compete",
+    cwd: applyBoundary.projectRoot,
+    currentBranch: applyTargetBranch,
+    effectiveCompletionMode
+  });
+  let appliedEvent;
+  let outcomeStreamPersist;
+  const applyContext = {
+    projectRoot: applyBoundary.projectRoot,
+    taskId,
+    createPr: options.createPr,
+    allowOffScopeRepair: options.allowOffScopeRepair,
+    branchApplyAuthority: applyBoundary.authority,
+    onApplicationFact,
+    deliveryPresentation: {
+      judgeWinnerId: judgeVerdictProduced ? winnerForApply.variantId : void 0,
+      substitutionReason,
+      ...judgeWinnerLine.presentation(winnerForApply),
+      taskPrompt: params.taskPrompt
+    },
+    resolvedConfig: resolvedConfig ? {
+      variants: resolvedConfig.variants,
+      judge: resolvedConfig.judge,
+      completionMode: resolvedConfig.completionMode,
+      timeout: resolvedConfig.timeout,
+      schemaHash: resolvedConfig.schemaHash
+    } : void 0,
+    onApplied: (event) => {
+      appliedEvent = event;
+      const isEmptyDiffNoOp = event.reason === "empty_diff";
+      const isNonApplyingOutcome = isEmptyDiffNoOp || event.mode === "isolated";
+      const postApplyVerificationFailed = event.postApplyVerification?.status === "failed";
+      const deliveryStatus = isEmptyDiffNoOp ? "not applied; empty diff" : event.mode === "isolated" ? "retained; no target changes applied" : event.mode === "pr" ? "published" : postApplyVerificationFailed ? "applied; verification failed" : formatPostApplyUnverifiedLabel(event.postApplyVerification, event.changedFiles) ? "applied, unverified" : "applied";
+      if (judgeVerdictProduced) console.log(judgeWinnerLine.announce(winnerForApply));
+      console.log(`Delivery artifact: ${event.variantId} (${deliveryStatus})`);
+      if (substitutionReason) console.log(`Delivery reason: ${substitutionReason}`);
+      const competitionOutcomeEvent = isNonApplyingOutcome ? void 0 : buildAppliedCompetitionOutcomeEvent({
+        taskId,
+        judgeVerdictProduced,
+        finalJudgeWinner: winnerForApply,
+        deliveryTarget: applyTarget,
+        synthesisDeliverySelected,
+        appliedEvent: event
+      });
+      const applyTargetBranchRole = applyTargetBranch ? classifyBranchRole(applyTargetBranch) : void 0;
+      const protectedOverride = event.mode === "branch" && applyTargetBranchRole === "protected" ? options.allowProtected ? "--allow-protected" : options.allowMain ? "--allow-main" : null : null;
+      telemetry.logCustomEvent({
+        event: isNonApplyingOutcome ? "completion_mode_noop" : "completion_mode_applied",
+        completion_mode: event.mode,
+        variant_id: event.variantId,
+        task_id: event.taskId ?? taskId,
+        applied_at: event.appliedAt,
+        source_branch: event.sourceBranch,
+        source_head_sha: event.sourceHeadSha,
+        target_branch: event.targetBranch,
+        target_pre_apply_head_sha: event.targetPreApplyHeadSha,
+        target_post_apply_head_sha: event.targetPostApplyHeadSha,
+        diff_source: event.diffSource,
+        files_changed: event.filesChanged,
+        changed_files: event.changedFiles,
+        reason: event.reason,
+        post_apply_verification_status: event.postApplyVerification?.status,
+        competition_outcome_event: competitionOutcomeEvent,
+        ...applyTargetBranch ? {
+          apply_target_branch: applyTargetBranch,
+          apply_target_branch_role: applyTargetBranchRole
+        } : {},
+        branch_role_action: commingledApply || protectedOverride ? "overridden" : event.mode === "branch" ? "product-fix" : "run-only",
+        branch_role_override: commingledApply ? "--allow-commingle-validation-output" : protectedOverride
+      });
+      updateEvaluationHandleApplicationProvenance(taskId, {
+        mode: event.mode,
+        // Isolated retention and empty_diff are no-ops: preserve provenance
+        // without claiming that target changes were applied.
+        status: isNonApplyingOutcome ? "skipped" : postApplyVerificationFailed ? "failed" : "applied",
+        variantId: event.variantId,
+        taskId: event.taskId ?? taskId,
+        appliedAt: event.appliedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        sourceBranch: event.sourceBranch,
+        sourceHeadSha: event.sourceHeadSha,
+        targetBranch: event.targetBranch ?? applyTargetBranch,
+        targetPreApplyHeadSha: event.targetPreApplyHeadSha,
+        targetPostApplyHeadSha: event.targetPostApplyHeadSha,
+        diffSource: event.diffSource,
+        prNumber: event.prNumber,
+        changedFiles: event.changedFiles,
+        filesChanged: event.filesChanged,
+        postApplyVerification: event.postApplyVerification
+      });
+      if (competitionOutcomeEvent) {
+        recordAppliedCompetitionOutcome(
+          telemetry,
+          event,
+          competitionOutcomeEvent,
+          judgeVerdictProduced
+        );
+        if (event.mode === "pr" || event.mode === "branch") {
+          outcomeStreamPersist = persistAppliedCompetitionOutcomeEvent(competitionOutcomeEvent);
+        }
+      }
+    }
+  };
+  try {
+    await applyCompletionMode(
+      applyTarget,
+      resolvedCompletionMode,
+      completionModeSource,
+      applyContext
+    );
+  } finally {
+    if (outcomeStreamPersist) {
+      await outcomeStreamPersist;
+    }
+  }
+  return appliedEvent;
+}
+function recordAppliedCompetitionOutcome(telemetry, event, competitionOutcomeEvent, judgeVerdictProduced) {
+  try {
+    if (!judgeVerdictProduced) return;
+    if (event.mode !== "pr" && event.mode !== "branch") return;
+    const db = telemetry.getVariantsDb();
+    if (!db) return;
+    const { projectId } = telemetry.getTelemetryContext();
+    const evaluationId = resolveLatestEvaluationId(db, projectId, competitionOutcomeEvent.taskId);
+    const prNumber = typeof event.prNumber === "number" && Number.isFinite(event.prNumber) ? event.prNumber : null;
+    recordCompetitionOutcomeEvent(db, {
+      projectId,
+      evaluationId,
+      outcomeKind: event.mode === "pr" && prNumber !== null ? "pr_opened" : "applied",
+      event: competitionOutcomeEvent,
+      prNumber,
+      commitSha: event.targetPostApplyHeadSha ?? null,
+      validationStatus: event.postApplyVerification?.status ?? null,
+      metadata: {
+        mode: event.mode,
+        targetBranch: event.targetBranch,
+        filesChanged: event.filesChanged
+      }
+    });
+  } catch (error) {
+    emitCustomWarning(
+      "WARN" /* WARN */,
+      "validation" /* VALIDATION */,
+      "Failed to record competition outcome telemetry",
+      {
+        taskId: competitionOutcomeEvent.taskId,
+        subsystem: "compete-finalize",
+        executionPhase: "cleanup"
+      },
+      {
+        skipConsole: true,
+        metadata: { error: error instanceof Error ? error.message : String(error) }
+      }
+    );
+  }
+}
+async function persistAppliedCompetitionOutcomeEvent(competitionOutcomeEvent) {
+  try {
+    const buildDir = resolveBuildDirFromContext();
+    await persistCompetitionOutcomeEvent(buildDir, competitionOutcomeEvent);
+  } catch (error) {
+    emitCustomWarning(
+      "WARN" /* WARN */,
+      "validation" /* VALIDATION */,
+      "Failed to persist competition outcome event stream",
+      {
+        taskId: competitionOutcomeEvent.taskId,
+        subsystem: "compete-finalize",
+        executionPhase: "cleanup"
+      },
+      {
+        skipConsole: true,
+        metadata: { error: error instanceof Error ? error.message : String(error) }
+      }
+    );
+  }
+}
+async function persistJudgeResults(taskId, variants, judgedWinner, buildDir = resolveBuildDirFromContext()) {
+  try {
+    const stateDir = LabPathResolver.getInstance().getVariantStateDir(buildDir);
+    await fs2.mkdir(stateDir, { recursive: true });
+    for (const variant of variants) {
+      if (judgedWinner.judgeEvaluation) {
+        const synthesis = judgedWinner.judgeEvaluation;
+        const candidateId = formatJudgeCandidateId(variant);
+        const evaluation = synthesis.evaluations?.find((e) => e.variant === candidateId);
+        if (evaluation) {
+          variant.judgeEvaluation = synthesis;
+          const bs = evaluation.bucketScores;
+          const rawScore = bs?.delivery != null && bs?.correctness != null && bs?.quality != null ? computeFinalScore({
+            delivery: bs.delivery,
+            correctness: bs.correctness,
+            quality: bs.quality
+          }) : evaluation.qualityScore;
+          variant.judgeScore = typeof rawScore === "number" ? rawScore : Number(rawScore) || void 0;
+        }
+      }
+      const canonicalFilename = `${taskVariantId(
+        taskId,
+        variant.provider,
+        variant.model,
+        variant.executionMode,
+        variant.workspaceMode,
+        {
+          cursorPromptProfile: variant.cursorPromptProfile,
+          variantInstanceId: variant.variantInstanceId
+        },
+        variant.requestedReasoningEffort
+      )}.json`;
+      const legacyFilename = `${taskId}-${variant.provider}-${variant.variant}.json`;
+      const canonicalPath = path3.join(stateDir, canonicalFilename);
+      const legacyPath = path3.join(stateDir, legacyFilename);
+      const canonicalExists = await fileExists(canonicalPath);
+      const legacyExists = await fileExists(legacyPath);
+      const filepath = canonicalExists ? canonicalPath : legacyExists ? legacyPath : await findVariantStateFile(stateDir, taskId, variant);
+      if (!filepath) continue;
+      try {
+        const existing = JSON.parse(await fs2.readFile(filepath, "utf-8"));
+        const merged = {
+          ...existing,
+          judgeEvaluation: variant.judgeEvaluation,
+          judgeScore: variant.judgeScore,
+          winnerSelectionSource: variant.winnerSelectionSource,
+          winnerSelectionReason: variant.winnerSelectionReason,
+          ...judgeVerificationStatePatch(variant)
+        };
+        await atomicWriteJson(filepath, merged);
+      } catch (error) {
+        const code = error?.code;
+        if (code === "ENOENT") {
+          continue;
+        }
+        console.warn(`Failed to persist judge data for ${filepath}:`, error);
+      }
+    }
+  } catch (error) {
+    console.warn("Failed to persist judge results to variant state files:", error);
+  }
+}
+function reconcileVariantResultsTelemetry(taskId, variants, telemetry, guidanceMetadata = {}) {
+  const db = telemetry.getVariantsDb();
+  const scope = telemetry.getTelemetryScope();
+  for (const variant of variants) {
+    try {
+      const canonicalKey = getCanonicalVariantKeyFromResult(variant);
+      let artifactManifest;
+      let executionProfileId;
+      let baselineRef;
+      let retainedWorktreePath;
+      let worktreeDiff;
+      let worktreeDiffReplayable = false;
+      if (db) {
+        const existing = db.prepare(
+          `SELECT result_json FROM variant_results WHERE ${scope.where} AND task_id = ? AND variant = ?`
+        ).get(...scope.params, taskId, canonicalKey);
+        if (existing?.result_json) {
+          try {
+            const existingJson = JSON.parse(existing.result_json);
+            artifactManifest = typeof existingJson.artifactManifest === "string" ? existingJson.artifactManifest : void 0;
+            executionProfileId = typeof existingJson.executionProfileId === "string" ? existingJson.executionProfileId : void 0;
+            baselineRef = typeof existingJson.baselineRef === "string" ? existingJson.baselineRef : void 0;
+            retainedWorktreePath = typeof existingJson.retainedWorktreePath === "string" ? existingJson.retainedWorktreePath : void 0;
+            worktreeDiffReplayable = existingJson.worktreeDiffReplayable === true;
+            worktreeDiff = typeof existingJson.worktreeDiff === "string" ? existingJson.worktreeDiff : void 0;
+          } catch {
+          }
+        }
+      }
+      const reconciledVariant = {
+        ...variant,
+        baselineRef: variant.baselineRef ?? baselineRef,
+        retainedWorktreePath: variant.retainedWorktreePath ?? retainedWorktreePath,
+        worktreeDiff: variant.worktreeDiff ?? worktreeDiff,
+        worktreeDiffReplayable: variant.worktreeDiff != null ? variant.worktreeDiffReplayable : worktreeDiffReplayable,
+        artifactManifest: variant.artifactManifest ?? artifactManifest
+      };
+      telemetry.logVariantResultSnapshot(taskId, canonicalKey, reconciledVariant, {
+        provider: variant.provider,
+        executionMode: variant.executionMode,
+        runMode: "basic-cli-native",
+        executionIntent: variant.executionIntent,
+        reconciledBy: "compete_task_parent",
+        artifactManifest,
+        executionProfileId,
+        executionGuidanceProfile: guidanceMetadata.executionGuidanceProfile,
+        executionGuidanceSource: guidanceMetadata.executionGuidanceSource,
+        placeholdersInRenderedPrompt: guidanceMetadata.placeholdersInRenderedPrompt,
+        renderedPromptHash: guidanceMetadata.renderedPromptHash
+      });
+    } catch (error) {
+      const label = variant.variant || `${variant.provider}:${variant.variant}`;
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(
+        `[telemetry] Failed to reconcile variant_results for ${taskId}/${label}: ${message}`
+      );
+    }
+  }
+}
+async function fileExists(filepath) {
+  try {
+    await fs2.stat(filepath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function shouldSkipJudgeEvaluationTelemetry(existing) {
+  return Boolean(existing.evaluation);
+}
+function buildAiJudgeEvaluationId(taskId) {
+  return `eval-${taskId}-consolidated`;
+}
+function buildMultiJudgeEvaluationIds(taskId) {
+  const multiJudgeTypes = ["ai", "multi-lens"];
+  return multiJudgeTypes.map((jt) => `eval-${taskId}-${jt}`);
+}
+async function logJudgeEvaluationTelemetry(telemetryLogger, taskId, variants, judgedWinner, closeCallThreshold) {
+  if (!telemetryLogger) return;
+  try {
+    const mappingAudit = judgedWinner?.judgeEvaluation?.metadata?.audit ?? variants.find((variant) => variant.judgeEvaluation?.metadata?.audit)?.judgeEvaluation?.metadata?.audit;
+    const variantLabelMapping = extractVariantLabelMappingFromAudit(mappingAudit);
+    try {
+      const db = telemetryLogger.getVariantsDb?.();
+      if (db) {
+        const checkStmt = db.prepare(`
+          SELECT COUNT(*) as count
+          FROM ai_judge_evaluations
+          WHERE task_id = ? AND evaluation_id IN (?, ?, ?, ?, ?)
+        `);
+        const evalIds = buildMultiJudgeEvaluationIds(taskId);
+        const result = checkStmt.get(taskId, ...evalIds);
+        if (result && result.count >= 2) {
+          return;
+        }
+      }
+    } catch {
+    }
+    try {
+      const existing = telemetryLogger.getJudgeEvaluationDetailsWithLabFallback(taskId);
+      if (shouldSkipJudgeEvaluationTelemetry(existing)) return;
+    } catch {
+    }
+    try {
+      const db = telemetryLogger.getVariantsDb?.();
+      if (db) {
+        const consolidatedId = buildAiJudgeEvaluationId(taskId);
+        const row = db.prepare("SELECT 1 FROM ai_judge_evaluations WHERE task_id = ? AND evaluation_id = ?").get(taskId, consolidatedId);
+        if (row) return;
+      }
+    } catch {
+    }
+    if (!judgedWinner || !judgedWinner.judgeEvaluation) return;
+    const synthesis = judgedWinner.judgeEvaluation;
+    const rawWinner = synthesis.winner;
+    const winnerVariant = judgedWinner.variant;
+    const winnerEval = synthesis.evaluations?.find((e) => e.variant === winnerVariant);
+    const winnerScore = Number(winnerEval?.qualityScore) || 0;
+    const overrideApplied = rawWinner !== winnerVariant;
+    const promptTelemetrySummary = extractPromptTelemetrySummaryFromAudit(
+      synthesis.metadata?.audit
+    );
+    const coverageAudit = synthesis.metadata?.audit?.coverage ?? void 0;
+    const winnerPrimaryReason = (!overrideApplied && typeof synthesis.winnerPrimaryReason === "string" ? synthesis.winnerPrimaryReason : typeof winnerEval?.primaryReason === "string" ? winnerEval.primaryReason : overrideApplied ? `Winner adjusted: ${rawWinner} \u2192 ${winnerVariant}.` : void 0) ?? void 0;
+    const winnerReasoning = !overrideApplied ? synthesis.reasoning : [
+      `Winner adjusted: ${rawWinner} \u2192 ${winnerVariant}.`,
+      winnerPrimaryReason ? `Final winner rationale: ${winnerPrimaryReason}` : null,
+      synthesis.reasoning ? `AI reasoning (pre-adjustments): ${synthesis.reasoning}` : null
+    ].filter(Boolean).join("\n\n");
+    const winnerReasoningWithPolicy = winnerReasoning;
+    const variantScores = applyVariantLabelsToScores(
+      (synthesis.evaluations || []).reduce((acc, evalEntry) => {
+        acc[evalEntry.variant] = {
+          scores: {
+            quality: Number(evalEntry.qualityScore) || 0
+          },
+          rationale: {
+            strengths: evalEntry.strengths || [],
+            weaknesses: evalEntry.weaknesses || []
+          },
+          confidence: Number(synthesis.metadata?.confidence ?? 0)
+        };
+        return acc;
+      }, {}),
+      variantLabelMapping
+    );
+    const top2Summary = getTop2FromSynthesis(synthesis);
+    const winnerVerified = isWinnerVerifiedByTelemetryResultSet(variants, judgedWinner);
+    const decisionStatus = inferDecisionStatus({
+      winnerSelectionReason: judgedWinner.winnerSelectionReason,
+      margin: top2Summary?.margin ?? null,
+      threshold: closeCallThreshold ?? null
+    });
+    const decisionOutcome = inferDecisionOutcome({
+      winnerSelectionSource: judgedWinner.winnerSelectionSource,
+      winnerSelectionReason: judgedWinner.winnerSelectionReason,
+      decisionStatus,
+      hasWinner: true,
+      winnerVerified
+    });
+    const consistencyTelemetry = extractJudgeConsistencyTelemetry(synthesis);
+    if (consistencyTelemetry.winnerOsBelowRunnerUp === true) {
+      emitWarning(
+        "VAL-001B",
+        {
+          taskId,
+          subsystem: "judge",
+          executionPhase: "validation"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            operation: "aiJudgeConsistencyTelemetry",
+            reason: "winner_os_below_runner_up",
+            winnerVariant
+          }
+        }
+      );
+    }
+    telemetryLogger.logJudgeEvaluation(taskId, buildAiJudgeEvaluationId(taskId), {
+      model: synthesis.metadata?.model ?? "ai-judge",
+      reportedModel: synthesis.metadata?.reportedModel,
+      evaluationTimeMs: synthesis.metadata?.evaluationTimeMs ?? 0,
+      totalVariants: variants.length,
+      winnerVariant,
+      winnerScore,
+      winnerConfidence: Number(synthesis.metadata?.confidence ?? 0),
+      winnerRationale: {
+        reasoning: winnerReasoningWithPolicy,
+        decisionStatus,
+        decisionOutcome,
+        winnerSelectionSource: judgedWinner.winnerSelectionSource,
+        winnerSelectionReason: judgedWinner.winnerSelectionReason,
+        margin: top2Summary?.margin,
+        top2: top2Summary?.top2,
+        recommendations: synthesis.recommendations,
+        winnerPrimaryReason,
+        ...coverageAudit ? { coverage: coverageAudit } : {},
+        evidenceUsage: synthesis.metadata?.audit?.evidenceUsage ?? void 0,
+        timingMs: synthesis.metadata?.audit?.timingMs && typeof synthesis.metadata.audit.timingMs === "object" ? synthesis.metadata.audit.timingMs : void 0,
+        ...promptTelemetrySummary ? { promptTelemetrySummary } : {}
+      },
+      variantLabelMapping,
+      variantScores,
+      rankingScoreInconsistency: consistencyTelemetry.rankingScoreInconsistency,
+      rankingLegacyDiverges: consistencyTelemetry.rankingLegacyDiverges,
+      winnerOsBelowRunnerUp: consistencyTelemetry.winnerOsBelowRunnerUp,
+      synthesisGenerated: false,
+      evaluationDurationMs: synthesis.metadata?.evaluationTimeMs ?? 0,
+      tokensUsed: typeof synthesis.metadata?.audit?.aiTokensUsed === "number" && Number.isFinite(synthesis.metadata.audit.aiTokensUsed) ? synthesis.metadata.audit.aiTokensUsed : typeof synthesis.metadata?.audit?.totalTokensUsed === "number" && Number.isFinite(synthesis.metadata.audit.totalTokensUsed) ? synthesis.metadata.audit.totalTokensUsed : void 0,
+      costUsd: typeof synthesis.metadata?.audit?.aiCostUsd === "number" && Number.isFinite(synthesis.metadata.audit.aiCostUsd) ? synthesis.metadata.audit.aiCostUsd : typeof synthesis.metadata?.audit?.totalCostUsd === "number" && Number.isFinite(synthesis.metadata.audit.totalCostUsd) ? synthesis.metadata.audit.totalCostUsd : void 0,
+      ...(() => {
+        const audit = synthesis.metadata?.audit;
+        if (!audit) return {};
+        const extras = {};
+        if (typeof audit.parentTurnsUsed === "number")
+          extras.parentTurnsUsed = audit.parentTurnsUsed;
+        if (typeof audit.parentMaxTurns === "number") extras.parentMaxTurns = audit.parentMaxTurns;
+        if (typeof audit.parentTurnUtilization === "number") {
+          extras.parentTurnUtilization = audit.parentTurnUtilization;
+        }
+        if (audit.parentTurnsSource === "cli_result" || audit.parentTurnsSource === "derived_assistant_messages") {
+          extras.parentTurnsSource = audit.parentTurnsSource;
+        }
+        return extras;
+      })()
+    });
+  } catch (error) {
+    console.warn(
+      `[compete] Failed to log judge evaluation telemetry for ${taskId}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+// src/cli/handlers/compete/concurrency-config.ts
+function asValidConcurrency(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
+}
+async function loadConfiguredConcurrency(explicitRequest) {
+  if (explicitRequest !== void 0) return {};
+  try {
+    const merged = await new ConfigManager().loadConfig();
+    return {
+      maxConcurrent: asValidConcurrency(merged.config.variants?.maxConcurrent),
+      worktreeMax: asValidConcurrency(merged.config.worktree?.maxConcurrent)
+    };
+  } catch (error) {
+    rethrowConfigValidityError(error);
+    return {};
+  }
+}
+function concurrencyAdvisoryMessage(effectiveMaxConcurrent) {
+  if (typeof effectiveMaxConcurrent !== "number") return void 0;
+  const legSlots = detectHostConcurrencyBudget().legSlots;
+  if (effectiveMaxConcurrent <= legSlots) return void 0;
+  return `Requested concurrency ${effectiveMaxConcurrent} exceeds this host's recommendation of ${legSlots} legs (see build doctor); running as asked.`;
+}
+
+// src/cli/handlers/compete/parse-provider-limits.ts
+function parseProviderLimits(providerLimit) {
+  if (!providerLimit || providerLimit.length === 0) {
+    return void 0;
+  }
+  const limits = {};
+  for (const entry of providerLimit) {
+    const parts = entry.split("=");
+    const providerInput = parts[0]?.trim() ?? "";
+    const limitInput = parts[1]?.trim() ?? "";
+    if (parts.length !== 2 || providerInput.length === 0 || limitInput.length === 0) {
+      throw new Error(`Invalid --provider-limit "${entry}": expected provider=positive-integer`);
+    }
+    if (!/^[1-9]\d*$/.test(limitInput)) {
+      throw new Error(`Invalid --provider-limit "${entry}": limit must be a positive integer`);
+    }
+    const limit = Number(limitInput);
+    if (!Number.isSafeInteger(limit)) {
+      throw new Error(`Invalid --provider-limit "${entry}": limit must be a positive integer`);
+    }
+    const provider = normalizeEngineId(providerInput);
+    if (!registry.has(provider)) {
+      throw new Error(
+        `Unknown provider "${providerInput}" in --provider-limit. Available providers: ${registry.getAllIds().join(", ")}`
+      );
+    }
+    limits[provider] = limit;
+  }
+  return limits;
+}
+
+// src/cli/handlers/compete/research-trace-persistence.ts
+import { mkdir as mkdir2, writeFile } from "fs/promises";
+import path4 from "path";
+function resolveNativeResearchTraceDir(buildDir, taskId, resolver = LabPathResolver.getInstance()) {
+  const labContext = resolver.getContext();
+  if (labContext) {
+    return path4.join(
+      buildDir,
+      "labs",
+      labContext.labId,
+      "runs",
+      labContext.runId,
+      "research",
+      taskId
+    );
+  }
+  return path4.join(buildDir, "research", taskId);
+}
+async function persistNativeResearchTraces(input) {
+  const traceDir = input.traceDir ?? resolveNativeResearchTraceDir(resolveBuildDirFromContext(input.buildDir), input.taskId);
+  const cleared = new Set(
+    Array.from(input.clearedProviders, (provider) => provider.trim().toLowerCase())
+  );
+  let traceDirReady = false;
+  let tracesPersisted = 0;
+  const failures = [];
+  for (const variant of input.variants) {
+    if (variant.success !== true) continue;
+    if (!cleared.has(variant.provider.trim().toLowerCase())) continue;
+    const variantKey = formatVariantIdentifierFromResult(variant);
+    const trace = parseCitationTrace({
+      variantId: variantKey,
+      provider: variant.provider,
+      mode: "native",
+      output: variant.result?.stdout ?? variant.output ?? "",
+      corroboratedUrls: variant.result?.researchCorroboratedUrls,
+      observedWebToolEvent: variant.result?.researchObservedWebToolEvent,
+      excludedDomains: input.excludedDomains
+    });
+    variant.researchTrace = trace;
+    try {
+      if (!traceDirReady) {
+        await mkdir2(traceDir, { recursive: true });
+        traceDirReady = true;
+      }
+      const tracePath = path4.join(
+        traceDir,
+        `${toVariantSlug(variantKey) || "variant"}-research-trace.json`
+      );
+      trace.artifactPath = tracePath;
+      await writeFile(tracePath, serializeCitationTrace(trace), "utf-8");
+      tracesPersisted++;
+    } catch (error) {
+      failures.push({
+        variantId: variantKey,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const totalCitations = input.variants.reduce(
+    (sum, variant) => sum + (variant.researchTrace?.citations.length ?? 0),
+    0
+  );
+  const excludedDomainViolations = input.variants.reduce(
+    (sum, variant) => sum + (variant.researchTrace?.citations.filter((citation) => citation.excludedDomainViolation).length ?? 0),
+    0
+  );
+  return { traceDir, totalCitations, excludedDomainViolations, tracesPersisted, failures };
+}
+
+// src/core/classification/deliverable-contract.ts
+var SOURCE_FILE_EXTENSION_ALT = getProjectReferencePathExtensions().map((ext) => ext.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+function parseDeliverableContract(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const c = value;
+  const isIntent = (v) => v === "code" || v === "analysis" || v === "mixed";
+  const isDeliverable = (v) => v === "analysis" || v === "code" || v === "doc" || v === "mixed";
+  const drift = c.drift;
+  if (!isDeliverable(c.deliverable) || typeof c.editsExpected !== "boolean" || typeof c.editsAllowed !== "boolean" || !isIntent(c.executionIntentEffective) || !isIntent(c.executionIntentOriginal) || typeof c.rationale !== "string" || !Array.isArray(c.requestedVerification) || !c.requestedVerification.every((item) => typeof item === "string") || drift !== void 0 && (typeof drift !== "object" || drift === null || typeof drift.detected !== "boolean" || typeof drift.reason !== "string")) {
+    return void 0;
+  }
+  return value;
+}
+function computeDeliverableContract(options) {
+  const {
+    executionIntent: originalIntent,
+    analysisOnly = false,
+    task,
+    analysis,
+    profileRequiresCode = false
+  } = options;
+  const isEvaluationStyleTask = options.isEvaluationStyleTask === true;
+  if (analysisOnly) {
+    return {
+      deliverable: "analysis",
+      editsExpected: false,
+      executionIntentEffective: "analysis",
+      executionIntentOriginal: originalIntent,
+      rationale: "--analysis-only flag explicitly requested analysis-only mode"
+    };
+  }
+  const hasCodeCues = detectCodeCues(task);
+  const hasExplicitTargets = hasExplicitFileTargets(task, {
+    includeScopedSections: true
+  });
+  const hasStructuredImplementationSpec = detectStructuredImplementationSpec(task, hasCodeCues);
+  const hasExplicitNoEditDirective = classifyExplicitNoEdit(task);
+  const hasGlobalNoEditDirective = hasExplicitNoEditDirective && detectGlobalNoEditDirective(task);
+  const hasActionableEditDirective = detectActionableEditDirective(task) || !hasGlobalNoEditDirective && detectUnlistedFileEditDirective(task);
+  const hasProseResponseOnlyDirective = detectProseResponseOnlyDirective(task);
+  const driftDetected = originalIntent === "analysis" && hasCodeCues && !isEvaluationStyleTask || originalIntent === "mixed" && (hasExplicitTargets || hasStructuredImplementationSpec || hasActionableEditDirective) && !isEvaluationStyleTask;
+  let effectiveIntent = originalIntent;
+  let deliverable = "analysis";
+  let editsExpected = false;
+  let driftReason = "";
+  if ((hasGlobalNoEditDirective || hasProseResponseOnlyDirective) && !hasExplicitTargets && !hasStructuredImplementationSpec && !hasActionableEditDirective) {
+    effectiveIntent = "analysis";
+    deliverable = "analysis";
+    editsExpected = false;
+    driftReason = hasGlobalNoEditDirective ? "Global no-edit directive detected" : "Prose response-only directive detected";
+  } else if (driftDetected) {
+    effectiveIntent = "code";
+    deliverable = "code";
+    editsExpected = true;
+    const expectedValidationArtifactCode = isValidationTargetedCodeOverrideExpected(task) && originalIntent === "mixed" && hasExplicitTargets;
+    if (!expectedValidationArtifactCode) {
+      driftReason = originalIntent === "mixed" ? hasExplicitTargets ? `FILE: markers detected; overriding ${originalIntent} intent to code` : hasStructuredImplementationSpec ? `Structured implementation spec detected; overriding ${originalIntent} intent to code` : `Actionable edit directive detected; overriding ${originalIntent} intent to code` : "Code cues detected in prompt (FILE:, implementation keywords)";
+    }
+  } else {
+    effectiveIntent = originalIntent;
+    if (originalIntent === "code") {
+      deliverable = "code";
+      editsExpected = true;
+    } else if (originalIntent === "analysis") {
+      deliverable = "analysis";
+      editsExpected = false;
+    } else {
+      deliverable = "mixed";
+      editsExpected = true;
+    }
+  }
+  if (!analysisOnly && effectiveIntent !== "analysis" && analysis?.intent === "analysis" && !hasExplicitTargets && !hasStructuredImplementationSpec && !hasActionableEditDirective && !profileRequiresCode && // Files the item's Scope declares outrank the analyzer's wording-based guess. Only this
+  // inferred override reads them: an explicit no-edit directive is decided above and
+  // --analysis-only before that, so a Scope never turns those into code.
+  extractScopedSourceFiles(task).length === 0) {
+    effectiveIntent = "analysis";
+    deliverable = "analysis";
+    editsExpected = false;
+    driftReason = "Analysis intent detected from prompt analysis";
+  }
+  if (!analysisOnly && effectiveIntent !== "analysis" && isEvaluationStyleTask && !profileRequiresCode) {
+    effectiveIntent = "analysis";
+    deliverable = "analysis";
+    editsExpected = false;
+    driftReason = "Evaluation-style task detected";
+  }
+  const rationaleParts = [];
+  if (analysisOnly) {
+    rationaleParts.push("--analysis-only flag");
+  } else if (driftDetected && driftReason) {
+    rationaleParts.push(`Drift detected: ${driftReason}`);
+    rationaleParts.push(`Original intent: ${originalIntent}, Effective: ${effectiveIntent}`);
+  } else {
+    rationaleParts.push(`Intent: ${effectiveIntent}`);
+  }
+  rationaleParts.push(`Deliverable: ${deliverable}, Edits expected: ${editsExpected}`);
+  return {
+    deliverable,
+    editsExpected,
+    executionIntentEffective: effectiveIntent,
+    executionIntentOriginal: originalIntent,
+    ...driftReason ? {
+      drift: {
+        detected: true,
+        reason: driftReason
+      }
+    } : {},
+    rationale: rationaleParts.join("; ")
+  };
+}
+function detectCodeCues(task) {
+  if (hasExplicitFileTargets(task, { includeScopedSections: true })) {
+    return true;
+  }
+  const codeKeywords = [
+    /\b(implement|implementation|fix|fixes|add|create|write|edit|update|modify|refactor|refactoring|prevent|secure|enforce|protect|guard)\b/i,
+    /\b(function|class|interface|type|const|let|var)\s+\w+/i,
+    /\b(test|tests|spec|specs)\s+(for|of|that)/i
+  ];
+  return codeKeywords.some((pattern) => pattern.test(task));
+}
+function detectStructuredImplementationSpec(task, hasCodeCues) {
+  if (!hasCodeCues) return false;
+  const hasAcceptanceCriteria = /^##\s+acceptance criteria\b/im.test(task);
+  const hasVerificationSection = /^##\s+how to verify\b/im.test(task);
+  const hasImplementationSections = /^##\s+scope(?:\s*\/\s*surfaces affected)?\b/im.test(task) || /^##\s+desired behavior\b/im.test(task) || /^##\s+problem\b/im.test(task);
+  return hasAcceptanceCriteria && (hasVerificationSection || hasImplementationSections);
+}
+function detectActionableEditDirective(task) {
+  const clauses = withoutNegatedSpans(task).split(/(?<=[.!?])\s+|\n+/).map((clause) => clause.trim()).filter(Boolean);
+  const editThenConcreteTarget = new RegExp(
+    // A qualified test is a concrete target in the singular too ("add a timing
+    // test", "add a micro-benchmark test"): only the bare noun "test" is too
+    // weak to imply a deliverable. An assertion is a test edit ("add one
+    // assertion per runner").
+    `\\b(add|create|write|edit|implement|update|modify|refactor|fix|migrate)\\b[\\s\\S]{0,120}\\b((focused\\s+)?unit\\s+tests?|automated\\s+tests?|regression\\s+tests?|integration\\s+tests?|e2e\\s+tests?|timing\\s+tests?|(?:micro[-\\s])?benchmark\\s+tests?|tests\\b|assertions?\\b|[A-Za-z0-9_./@+-]+\\.(?:${SOURCE_FILE_EXTENSION_ALT}))\\b`,
+    "i"
+  );
+  return clauses.some((clause) => editThenConcreteTarget.test(clause));
+}
+function detectUnlistedFileEditDirective(task) {
+  const negatedEditClause = /\b(?:do\s+not|don['']t|without)\s+(?:\w+\s+){0,4}(?:modify|change|edit|update|fix|migrate|touch)\b/i;
+  const fileEditVerbThenFile = /\b(?:edit|update|modify|refactor|fix|migrate)\s+(?:the\s+)?[`'"]?[A-Za-z0-9_./@+-]*[A-Za-z0-9_-]{2}\.[A-Za-z][A-Za-z0-9]{1,9}\b/i;
+  return task.split(/(?<=[.!?])\s+|\n+/).some((clause) => !negatedEditClause.test(clause) && fileEditVerbThenFile.test(clause));
+}
+function detectGlobalNoEditDirective(task) {
+  const clauses = task.split(/(?<=[.!?])\s+|\n+/).map((clause) => clause.trim()).filter(Boolean);
+  const noEditDirective = /\b(?:do\s+not|don['']t|without|no)\s+(?:\w+\s+){0,4}(?:modify|change|edit|write|create|add|touch|code\s+changes?|edits?)\b/i;
+  const blanketAnalysisOnly = /\b(?:return|record|provide)\s+(?:findings|analysis|assessment|report)\s+only\b|\b(?:only|just)\s+analy(?:s|z)e\b|\banalysis[- ]only\b|\bread[- ]only\b|\bno\s+code\s+changes?\b/i;
+  const scopedFileToken = new RegExp(
+    `\`[^\`]+\\.[A-Za-z0-9]+\`|[A-Za-z0-9_./@+-]+\\.(?:${SOURCE_FILE_EXTENSION_ALT})\\b|\`\\.[^\`]+\\/\`|\\.[A-Za-z0-9_-]+\\/`,
+    "i"
+  );
+  return clauses.some(
+    (clause) => (noEditDirective.test(clause) || blanketAnalysisOnly.test(clause)) && !scopedFileToken.test(clause)
+  );
+}
+
+// src/cli/utils/completion-receipt.ts
+function formatUsage(report) {
+  if (report.usage.status === "partial") {
+    return `tokens partial (${report.coverage.usageReportedInvocations}/${report.coverage.invocations} invocations reported)`;
+  }
+  const total = report.usage.billableTokens === null ? "tokens unavailable" : `${formatTokens(report.usage.billableTokens)} billable tokens`;
+  return report.usage.ambiguousDimensions.length > 0 ? `${total} (ambiguous: ${report.usage.ambiguousDimensions.join(", ")})` : total;
+}
+function formatTaskReportCostLabel(report) {
+  const cost = report.cost;
+  switch (cost.status) {
+    case "available":
+      return `$${cost.apiEquivalentUsd.toFixed(4)} (API list price; ${report.coverage.invocations} invocations)`;
+    case "partial":
+      if (cost.estimatedApiEquivalentUsd !== void 0) {
+        return `~$${cost.estimatedApiEquivalentUsd.toFixed(4)} (API list price estimate; pricing partial)`;
+      }
+      if (cost.knownApiEquivalentUsd !== void 0) {
+        return `$${cost.knownApiEquivalentUsd.toFixed(4)} known (API list price; partial, ${cost.pricedInvocations}/${cost.totalInvocations} invocations priced)`;
+      }
+      return `partial (${cost.pricedInvocations}/${cost.totalInvocations} invocations priced)`;
+    case "unavailable":
+      return report.coverage.invocations > 0 ? `unavailable (${cost.reason.replaceAll("_", " ")})` : void 0;
+  }
+}
+function formatCost(report) {
+  switch (report.cost.status) {
+    case "available":
+      return `API-equivalent cost $${report.cost.apiEquivalentUsd.toFixed(4)}`;
+    case "partial":
+      if (report.cost.estimatedApiEquivalentUsd !== void 0) {
+        return `API-equivalent cost ~$${report.cost.estimatedApiEquivalentUsd.toFixed(4)} (estimate; pricing partial)`;
+      }
+      if (report.cost.knownApiEquivalentUsd !== void 0) {
+        return `cost partial (${report.cost.pricedInvocations}/${report.cost.totalInvocations} invocations priced; known API-equivalent $${report.cost.knownApiEquivalentUsd.toFixed(4)} across ${report.cost.knownAmountInvocations ?? report.cost.pricedInvocations})`;
+      }
+      return `cost partial (${report.cost.pricedInvocations}/${report.cost.totalInvocations} invocations priced)`;
+    case "unavailable":
+      return `cost unavailable (${report.cost.reason.replaceAll("_", " ")})`;
+  }
+}
+var MAX_RECEIPT_MODELS = 3;
+function formatModels(report) {
+  const models = report.models ?? [];
+  if (models.length === 0) return void 0;
+  const shown = models.slice(0, MAX_RECEIPT_MODELS).map((model) => {
+    const details = [
+      ...model.requestedModel ? [`requested ${model.requestedModel}`] : [],
+      ...model.contextWindow ? [`context ${formatTokens(model.contextWindow)}`] : []
+    ];
+    const name = `${model.provider}/${model.executedModel}`;
+    return details.length > 0 ? `${name} (${details.join(", ")})` : name;
+  });
+  const hidden = models.length - shown.length;
+  return `models ${shown.join("; ")}${hidden > 0 ? `; +${hidden} more` : ""}`;
+}
+function formatTaskReportReceipt(report, options = {}) {
+  const wallMs = options.wallMs ?? report.duration.wallMs;
+  const durationLabel = wallMs !== null && wallMs !== void 0 ? `Completed in ${formatDurationMs(wallMs)}` : report.duration.providerBusyMs !== null ? `Provider busy ${formatDurationMs(report.duration.providerBusyMs)}` : "Completed (duration unavailable)";
+  const models = formatModels(report);
+  return `${durationLabel} | ${formatUsage(report)} | ${formatCost(report)}${models ? ` | ${models}` : ""}`;
+}
+
+// src/orchestrator/judge-completeness-telemetry.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toJsonValue(value) {
+  if (value === null) return null;
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+  if (Array.isArray(value)) {
+    return value.map((item) => toJsonValue(item)).filter((item) => item !== void 0);
+  }
+  if (isRecord(value)) {
+    const record = {};
+    for (const [key, item] of Object.entries(value)) {
+      const jsonValue = toJsonValue(item);
+      if (jsonValue !== void 0) {
+        record[key] = jsonValue;
+      }
+    }
+    return record;
+  }
+  return void 0;
+}
+function asJsonArray(value) {
+  const jsonValue = toJsonValue(value);
+  return Array.isArray(jsonValue) && jsonValue.length > 0 ? jsonValue : void 0;
+}
+function getStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+}
+function collectNegativeSpace(workerPackets) {
+  if (!Array.isArray(workerPackets)) return void 0;
+  const entries = [];
+  for (const packet of workerPackets) {
+    if (!isRecord(packet) || typeof packet.variantId !== "string") continue;
+    const items = getStringArray(packet.negativeSpace);
+    if (items.length > 0) {
+      entries.push({ variant: packet.variantId, items });
+    }
+  }
+  return entries.length > 0 ? entries : void 0;
+}
+function collectEvidenceConcerns(workerEvidenceMatrix) {
+  if (!isRecord(workerEvidenceMatrix)) return void 0;
+  const concerns = [];
+  const criteriaRows = Array.isArray(workerEvidenceMatrix.criteriaRows) ? workerEvidenceMatrix.criteriaRows : [];
+  for (const row of criteriaRows) {
+    if (!isRecord(row) || !isRecord(row.variants)) continue;
+    const item = typeof row.criterion === "string" ? row.criterion : typeof row.criterionKey === "string" ? row.criterionKey : "acceptance criterion";
+    for (const [variant, cell] of Object.entries(row.variants)) {
+      if (!isRecord(cell)) continue;
+      const evidenceStatus = cell.evidenceStatus === "valid" || cell.evidenceStatus === "invalid" || cell.evidenceStatus === "missing" ? cell.evidenceStatus : void 0;
+      const evidenceKind = typeof cell.evidenceKind === "string" ? cell.evidenceKind : void 0;
+      const category = evidenceKind === "unverifiable" || evidenceStatus === "invalid" ? "unverifiable" : evidenceStatus === "missing" || evidenceKind === "missing" ? "missing" : void 0;
+      if (category) {
+        concerns.push({
+          variant,
+          item,
+          category,
+          ...evidenceStatus ? { evidenceStatus } : {},
+          ...evidenceKind ? { evidenceKind } : {}
+        });
+      }
+    }
+  }
+  const emergentFindings = Array.isArray(workerEvidenceMatrix.emergentFindings) ? workerEvidenceMatrix.emergentFindings : [];
+  for (const finding of emergentFindings) {
+    if (!isRecord(finding) || !isRecord(finding.variants)) continue;
+    const item = typeof finding.finding === "string" ? finding.finding : typeof finding.findingKey === "string" ? finding.findingKey : "emergent finding";
+    for (const [variant, cell] of Object.entries(finding.variants)) {
+      if (!isRecord(cell)) continue;
+      const evidenceStatus = cell.evidenceStatus === "valid" || cell.evidenceStatus === "invalid" || cell.evidenceStatus === "missing" ? cell.evidenceStatus : void 0;
+      const status = typeof cell.status === "string" ? cell.status : void 0;
+      const category = status === "unverifiable" || evidenceStatus === "invalid" ? "unverifiable" : evidenceStatus === "missing" ? "missing" : void 0;
+      if (category) {
+        concerns.push({
+          variant,
+          item,
+          category,
+          ...evidenceStatus ? { evidenceStatus } : {}
+        });
+      }
+    }
+  }
+  return concerns.length > 0 ? concerns : void 0;
+}
+function buildJudgeCompletenessTelemetryFromEvaluation(judgeEvaluation) {
+  const audit = judgeEvaluation?.metadata?.audit;
+  if (!isRecord(audit)) return void 0;
+  const coverageGaps = asJsonArray(audit.coverageGaps);
+  const negativeSpaceByVariant = collectNegativeSpace(audit.workerPackets);
+  const evidenceConcerns = collectEvidenceConcerns(audit.workerEvidenceMatrix);
+  const workerEvidenceMatrix = toJsonValue(audit.workerEvidenceMatrix);
+  if (!coverageGaps && !negativeSpaceByVariant && !evidenceConcerns && workerEvidenceMatrix === void 0) {
+    return void 0;
+  }
+  return {
+    source: "judge-audit",
+    ...coverageGaps ? { coverageGaps } : {},
+    ...negativeSpaceByVariant ? { negativeSpaceByVariant } : {},
+    ...evidenceConcerns ? { evidenceConcerns } : {},
+    ...workerEvidenceMatrix !== void 0 ? { workerEvidenceMatrix } : {}
+  };
+}
+function buildJudgeCompletenessTelemetryFromVariants(variants) {
+  for (const variant of variants) {
+    const telemetry = buildJudgeCompletenessTelemetryFromEvaluation(variant.judgeEvaluation);
+    if (telemetry) return telemetry;
+  }
+  return void 0;
+}
+
+// src/cli/handlers/compete/execute-competition-synthesis.ts
+import * as path6 from "path";
+import { execa } from "execa";
+
+// src/core/synthesis/fusion-synthesizer.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir3, rename, unlink, writeFile as writeFile2 } from "fs/promises";
+import path5 from "path";
+
+// src/core/synthesis/fusion-synthesis-types.ts
+var FUSION_SYNTHESIS_MANIFEST_VERSION = 2;
+var FUSION_SYNTHESIS_COMPLETION_MARKER = "<!-- BUILD_FUSION_COMPLETE -->";
+
+// src/core/synthesis/fusion-synthesizer.ts
+var MAX_FUSION_PROMPT_CHARS = 18e4;
+var MAX_FUSION_RESPONSE_BYTES = 1e6;
+var DEFAULT_FUSION_SYNTHESIS_TIMEOUT_MS = 15 * 60 * 1e3;
+var OMITTED_OUTPUT = "[omitted from synthesis artifact; inspect contributor artifacts]";
+function isSynthesisPin(resolved) {
+  return [resolved.providerSourcePath, resolved.modelSourcePath].some(
+    (sourcePath) => sourcePath.startsWith("cli:") || sourcePath.startsWith("env:BUILD_SYNTHESIS_")
+  );
+}
+function resolveFusionSynthesisTarget(synthesisModel, cwd) {
+  const target = synthesisModel ? parseSynthesisModelTarget(synthesisModel) : void 0;
+  const resolved = resolvePreferred("synthesis", {
+    cli: { synthesisProvider: target?.provider, synthesisModel: target?.model },
+    cwd
+  });
+  const reasoningEffort = resolveSynthesisReasoningEffort(
+    target?.effort ? { reasoningEffort: target.effort } : void 0,
+    cwd,
+    resolved.provider
+  )?.value;
+  return { resolved, reasoningEffort };
+}
+function synthesisFallbacks(resolved, cwd) {
+  if (!isFailoverEnabled(cwd)) return void 0;
+  return resolveCandidates("synthesis", { cwd, preserveFallbackChain: true }).filter((candidate) => candidate.provider !== resolved.provider).map(({ provider, model }) => ({ provider, model }));
+}
+function classifySynthesisRunnerFailure(error) {
+  const category = classifyNoWorkFailure(error);
+  if (category !== "unknown") return category;
+  const { stderr } = error ?? {};
+  return typeof stderr === "string" ? classifyProviderResultFailure({ stdout: "", stderr, exitCode: 1 }) : "unknown";
+}
+function buildArtifactPaths(root, taskId) {
+  return {
+    answerPath: path5.join(root, `${taskId}.md`),
+    manifestPath: path5.join(root, `${taskId}.manifest.json`),
+    promptPath: path5.join(root, `${taskId}.prompt.md`),
+    rawResponsePath: path5.join(root, `${taskId}.raw.txt`),
+    replayPath: path5.join(root, `${taskId}.replay.json`)
+  };
+}
+async function atomicWrite(filePath, contents) {
+  await mkdir3(path5.dirname(filePath), { recursive: true });
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await writeFile2(tempPath, contents, "utf8");
+    await rename(tempPath, filePath);
+  } catch (error) {
+    try {
+      await unlink(tempPath);
+    } catch {
+    }
+    throw error;
+  }
+}
+function renderFusionPrompt(input) {
+  const variants = input.inputs.variants.map((variant) => {
+    const limit = input.perVariantLimit;
+    const output = limit === void 0 || variant.output.length <= limit ? variant.output : `${variant.output.slice(0, Math.max(0, limit))}
+[truncated]`;
+    return { ...variant, output };
+  });
+  const metadata = {
+    ...input.inputs,
+    variants
+  };
+  return `You are producing Build's final Fusion answer from equal peer contributors.
+
+Return the complete answer to the Original task as Markdown. Do not return JSON or wrap the
+answer in an extra code fence unless the task explicitly requests it. Integrate useful agreement,
+preserve material disagreements and uncertainty in the answer where they affect the recommendation,
+and obey the task's requested headings, order, audience, and output format. Contributor identifiers
+are provenance handles, not rankings. Do not declare a winning contributor.
+
+When a contributor has a researchTrace, use its citations for research-derived claims and do not
+invent citations. Treat hostState as authoritative for current repository state. Contributor claims
+that conflict with hostState must be labeled stale, uncorroborated, or provider self-report.
+
+Do not assert as established fact any load-bearing claim (one a headline, recommendation, or
+conclusion depends on) that only a single contributor makes or that contributors dispute: attribute
+it to its source or mark it unverified. Never elevate a single contributor's unverified factual
+claim to a headline. When contributors conflict on a factual claim, surface the disagreement rather
+than silently choosing one side.
+
+End the response with this marker on its own final line:
+${FUSION_SYNTHESIS_COMPLETION_MARKER}
+
+Original task:
+${input.task}
+
+Host-owned inputs:
+${JSON.stringify(metadata, null, 2)}
+`;
+}
+function buildBoundedPrompt(task, inputs) {
+  const full = renderFusionPrompt({ task, inputs });
+  if (full.length <= MAX_FUSION_PROMPT_CHARS) {
+    return { prompt: full, truncatedContributorIds: [] };
+  }
+  let low = 0;
+  let high = Math.max(0, ...inputs.variants.map((variant) => variant.output.length));
+  let best = null;
+  let bestLimit = 0;
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2);
+    const candidate = renderFusionPrompt({ task, inputs, perVariantLimit: middle });
+    if (candidate.length <= MAX_FUSION_PROMPT_CHARS) {
+      best = candidate;
+      bestLimit = middle;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  if (!best) {
+    throw new Error("Fusion prompt metadata exceeds the bounded prompt budget");
+  }
+  return {
+    prompt: best,
+    truncatedContributorIds: inputs.variants.filter((variant) => variant.output.length > bestLimit).map((variant) => variant.variantId),
+    perContributorChars: bestLimit
+  };
+}
+function stripCompletionMarker(output, providerCompleted) {
+  const normalized = output.replace(/\r\n/g, "\n");
+  const markerPattern = new RegExp(
+    `${providerCompleted ? "" : "(?:^|\\n)"}${FUSION_SYNTHESIS_COMPLETION_MARKER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*$`
+  );
+  const observed = markerPattern.test(normalized);
+  const answer = observed ? normalized.replace(markerPattern, "").trimEnd() : normalized.trimEnd();
+  return { answer, observed };
+}
+function boundResponse(output) {
+  const bytes = Buffer.from(output, "utf8");
+  if (bytes.length <= MAX_FUSION_RESPONSE_BYTES) return { text: output, exceeded: false };
+  let text = bytes.subarray(0, MAX_FUSION_RESPONSE_BYTES).toString("utf8");
+  while (text.endsWith("\uFFFD")) text = text.slice(0, -1);
+  return { text: `${text.trimEnd()}
+[truncated]`, exceeded: true };
+}
+function summarizeAnswer(answer, answerPath) {
+  return summarizeFusionSections(answer) ?? `Fusion answer has no section headings; read the saved document${answerPath ? ` at ${answerPath}` : ""}.`;
+}
+function compatibilityInputs(options) {
+  return {
+    variants: options.variants.map((variant) => ({ ...variant, output: OMITTED_OUTPUT })),
+    selectedTopN: options.variants.length,
+    ...options.metadata?.task ? {
+      task: sanitizeSynthesisArtifactForPersistence(
+        options.metadata.task
+      )
+    } : {},
+    ...options.metadata?.research ? {
+      research: sanitizeSynthesisArtifactForPersistence(
+        options.metadata.research
+      )
+    } : {},
+    ...options.metadata?.contributorHealth ? {
+      contributorHealth: sanitizeSynthesisArtifactForPersistence(
+        options.metadata.contributorHealth
+      )
+    } : {},
+    ...options.metadata?.hostState ? {
+      hostState: sanitizeSynthesisArtifactForPersistence(
+        options.metadata.hostState
+      )
+    } : {}
+  };
+}
+function buildCompatibilityResult(input) {
+  const statuses = Object.fromEntries(
+    (input.inputs.contributorHealth ?? []).map((contributor) => [
+      contributor.variantId,
+      contributor.status
+    ])
+  );
+  const integrated = Object.values(statuses).filter((status) => status === "included").length;
+  const total = input.inputs.contributorHealth?.length ?? input.inputs.variants.length;
+  return {
+    schemaVersion: 2,
+    status: input.status,
+    crossVariant: {
+      consensus: [],
+      contradictions: [],
+      partialCoverage: [],
+      uniqueInsights: [],
+      blindSpots: []
+    },
+    finalRecommendation: {
+      summary: input.answer ? summarizeAnswer(input.answer, input.answerPath) : "Fusion synthesis unavailable.",
+      recommendation: input.answer,
+      rationale: [],
+      risks: [],
+      nextSteps: []
+    },
+    provenance: input.provenance,
+    inputs: input.inputs,
+    trust: {
+      ...integrated >= 2 ? { peerFraming: "equal_peers_no_selection" } : {},
+      contributors: {
+        integrated,
+        total,
+        incomplete: integrated < total,
+        statuses
+      }
+    },
+    ...input.inputTruncation ? { inputTruncation: input.inputTruncation } : {},
+    ...input.error ? { error: input.error } : {},
+    persistence: input.persistence
+  };
+}
+function persistenceFromWritten(written, errors, expected) {
+  const intended = ["prompt", "manifest"];
+  if (expected.rawResponse) intended.push("rawResponse");
+  if (expected.markdown) intended.push("markdown");
+  const count = intended.filter((key) => written[key] === true).length;
+  return {
+    status: count === intended.length ? "written" : count === 0 ? "failed" : "partial",
+    ...errors.length > 0 ? { error: sanitizeDiagnosticOutput(errors.join("; "), 1200) ?? "artifact write failed" } : {},
+    written
+  };
+}
+async function runFusionSynthesis(options) {
+  const paths = buildArtifactPaths(options.artifactRootDir, options.taskId);
+  const written = {};
+  const writeErrors = [];
+  const startedAt = Date.now();
+  const inputs = compatibilityInputs(options);
+  let status = "succeeded";
+  const degradedReasons = [];
+  let providerCompleted = false;
+  let terminalOutputPresent = false;
+  let completionMarkerObserved = false;
+  let responseBoundExceeded = false;
+  let rawOutput = "";
+  let answer = "";
+  let errorMessage;
+  const persistenceExpected = {
+    rawResponse: options.variants.length >= 2,
+    markdown: false
+  };
+  const providerUsage = {};
+  const provenance = {};
+  let prompt = "";
+  let inputTruncation;
+  try {
+    const { resolved, reasoningEffort } = resolveFusionSynthesisTarget(
+      options.synthesisModel,
+      options.workingDir ?? process.cwd()
+    );
+    Object.assign(provenance, {
+      provider: resolved.provider,
+      model: resolved.model,
+      reasoningEffort
+    });
+    if (options.variants.length < 2) {
+      prompt = options.variants.length === 0 ? "Fusion provider was not invoked because no usable contributors were available." : `Fusion provider was not invoked because the sole contributor ${options.variants[0]?.variantId ?? "unknown"} was returned directly.`;
+    } else {
+      const boundedPrompt = buildBoundedPrompt(options.task, {
+        ...inputs,
+        variants: options.variants
+      });
+      prompt = boundedPrompt.prompt;
+      if (boundedPrompt.truncatedContributorIds.length > 0 && boundedPrompt.perContributorChars !== void 0) {
+        const affected = new Set(boundedPrompt.truncatedContributorIds);
+        const perContributorChars = boundedPrompt.perContributorChars;
+        inputTruncation = {
+          affectedContributors: boundedPrompt.truncatedContributorIds,
+          perContributorChars,
+          contributors: options.variants.filter((variant) => affected.has(variant.variantId)).map((variant) => ({
+            variantId: variant.variantId,
+            originalChars: variant.output.length,
+            consumedChars: Math.min(variant.output.length, perContributorChars)
+          }))
+        };
+      }
+    }
+    await atomicWrite(paths.promptPath, sanitizeSynthesisStringForPersistence(prompt));
+    written.prompt = true;
+    if (options.variants.length === 0) {
+      status = "skipped";
+      degradedReasons.push("no_usable_contributors");
+    } else if (options.variants.length === 1) {
+      status = "degraded";
+      degradedReasons.push("fewer_than_two_contributors");
+      answer = (options.variants[0]?.output ?? "").trimEnd();
+    } else {
+      const runner = options.providerRunner ?? runAnalysisSynthesisProvider;
+      const cwd = options.workingDir ?? process.cwd();
+      try {
+        const { value: attempted } = await runWithProviderFailover({
+          first: { provider: resolved.provider, model: resolved.model },
+          fallbacks: isSynthesisPin(resolved) ? void 0 : () => synthesisFallbacks(resolved, cwd),
+          callSite: "fusion-synthesis",
+          attempt: (candidate) => runner(prompt, {
+            provider: candidate.provider,
+            model: candidate.model,
+            modelReasoningEffort: candidate.provider === resolved.provider ? reasoningEffort : resolveSynthesisReasoningEffort(void 0, cwd, candidate.provider)?.value,
+            taskId: options.taskId,
+            workingDir: cwd,
+            timeoutMs: options.timeoutMs ?? DEFAULT_FUSION_SYNTHESIS_TIMEOUT_MS
+          }).then(
+            (output2) => ({ output: output2 }),
+            (error) => ({ error })
+          ),
+          failureOf: (attempted2) => "error" in attempted2 ? classifySynthesisRunnerFailure(attempted2.error) : void 0,
+          onSwitch: options.onProviderSwitch ?? printProviderSwitchNotice
+        });
+        if ("error" in attempted) throw attempted.error;
+        const { output } = attempted;
+        providerCompleted = true;
+        rawOutput = output.stdout;
+        provenance.provider = output.invocation.provider;
+        provenance.model = output.invocation.model;
+        provenance.reasoningEffort = output.invocation.reasoningEffort;
+        if (typeof output.totalCostUsd === "number") {
+          providerUsage.totalCostUsd = output.totalCostUsd;
+        }
+        if (typeof output.tokenUsage?.inputTokens === "number") {
+          providerUsage.inputTokens = output.tokenUsage.inputTokens;
+        }
+        if (typeof output.tokenUsage?.outputTokens === "number") {
+          providerUsage.outputTokens = output.tokenUsage.outputTokens;
+        }
+      } catch (error) {
+        const providerError = error;
+        errorMessage = sanitizeDiagnosticOutput(providerError.message, 1200) ?? "Fusion provider failed";
+        rawOutput = typeof providerError.stdout === "string" ? providerError.stdout : typeof providerError.rawStdout === "string" ? providerError.rawStdout : "";
+        degradedReasons.push("provider_failed");
+      }
+      const bounded = boundResponse(rawOutput);
+      responseBoundExceeded = bounded.exceeded;
+      terminalOutputPresent = bounded.text.trim().length > 0;
+      const stripped = stripCompletionMarker(bounded.text, providerCompleted);
+      completionMarkerObserved = stripped.observed;
+      answer = stripped.answer;
+      if (!providerCompleted && !completionMarkerObserved) answer = "";
+      if (responseBoundExceeded) degradedReasons.push("response_bound_exceeded");
+      if (!completionMarkerObserved) degradedReasons.push("completion_marker_missing");
+      if (!providerCompleted) degradedReasons.push("provider_completion_unconfirmed");
+      if (answer.trim().length === 0) {
+        status = "failed";
+        degradedReasons.push("empty_synthesis_answer");
+      } else if (degradedReasons.length > 0) {
+        status = "degraded";
+      }
+    }
+  } catch (error) {
+    status = "failed";
+    errorMessage = sanitizeDiagnosticOutput(error instanceof Error ? error.message : String(error), 1200) ?? "Fusion synthesis failed";
+    degradedReasons.push("host_synthesis_failure");
+  }
+  answer = stripPreambleBeforeFirstHeading(answer);
+  const redaction = redactSynthesisDeliverableSecrets(answer);
+  answer = redaction.value;
+  persistenceExpected.markdown = answer.trim().length > 0;
+  if (redaction.redacted) degradedReasons.push("secret_redaction_applied");
+  if (degradedReasons.length > 0 && status === "succeeded") status = "degraded";
+  if (options.variants.length >= 2) {
+    try {
+      await atomicWrite(
+        paths.rawResponsePath,
+        sanitizeSynthesisStringForPersistence(boundResponse(rawOutput).text)
+      );
+      written.rawResponse = true;
+    } catch (error) {
+      writeErrors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  if (answer.trim().length > 0) {
+    try {
+      await atomicWrite(paths.answerPath, answer.endsWith("\n") ? answer : `${answer}
+`);
+      written.markdown = true;
+    } catch (error) {
+      writeErrors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  if (answer.trim().length > 0 && written.markdown !== true) {
+    status = "failed";
+    degradedReasons.push("answer_persistence_failed");
+  }
+  if (options.isLabRun === true) {
+    try {
+      const replayCorpus = {
+        schemaVersion: 1,
+        kind: "fusion-replay-corpus",
+        taskId: options.taskId,
+        task: options.task,
+        variants: options.variants,
+        ...options.metadata ? { metadata: options.metadata } : {}
+      };
+      await atomicWrite(paths.replayPath, `${JSON.stringify(replayCorpus, null, 2)}
+`);
+      written.replay = true;
+    } catch (error) {
+      writeErrors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  Object.assign(provenance, providerUsage, {
+    rawResponsePath: written.rawResponse ? paths.rawResponsePath : void 0,
+    durationMs: Date.now() - startedAt
+  });
+  const preManifestPersistence = persistenceFromWritten(written, writeErrors, persistenceExpected);
+  const manifest = {
+    schemaVersion: FUSION_SYNTHESIS_MANIFEST_VERSION,
+    kind: "fusion-synthesis-manifest",
+    taskId: options.taskId,
+    status,
+    degradedReasons: [...new Set(degradedReasons)],
+    ...inputTruncation ? { inputTruncation } : {},
+    ...written.markdown ? {
+      answer: {
+        path: formatAnalysisSynthesisArtifactPath(paths.answerPath),
+        sha256: createHash("sha256").update(answer.endsWith("\n") ? answer : `${answer}
+`).digest("hex"),
+        bytes: Buffer.byteLength(answer.endsWith("\n") ? answer : `${answer}
+`, "utf8"),
+        secretRedactionApplied: redaction.redacted
+      }
+    } : {},
+    contributors: inputs.contributorHealth ?? [],
+    provenance: sanitizeSynthesisArtifactForPersistence({
+      ...provenance,
+      promptPath: written.prompt ? formatAnalysisSynthesisArtifactPath(paths.promptPath) : void 0,
+      rawResponsePath: written.rawResponse ? formatAnalysisSynthesisArtifactPath(paths.rawResponsePath) : void 0
+    }),
+    completion: {
+      providerCompleted,
+      terminalOutputPresent,
+      completionMarkerObserved,
+      responseBoundExceeded
+    },
+    ...inputs.research ? { research: inputs.research } : {},
+    ...inputs.hostState ? { hostState: inputs.hostState } : {},
+    artifacts: {
+      ...written.prompt ? { promptPath: formatAnalysisSynthesisArtifactPath(paths.promptPath) } : {},
+      ...written.rawResponse ? { rawResponsePath: formatAnalysisSynthesisArtifactPath(paths.rawResponsePath) } : {},
+      ...written.markdown ? { answerPath: formatAnalysisSynthesisArtifactPath(paths.answerPath) } : {},
+      manifestPath: formatAnalysisSynthesisArtifactPath(paths.manifestPath),
+      ...written.replay ? { replayPath: formatAnalysisSynthesisArtifactPath(paths.replayPath) } : {}
+    },
+    persistence: preManifestPersistence,
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...errorMessage ? { error: errorMessage } : {}
+  };
+  try {
+    const finalPersistence = {
+      ...persistenceFromWritten(
+        { ...written, manifest: true, json: true },
+        writeErrors,
+        persistenceExpected
+      ),
+      written: { ...written, manifest: true, json: true }
+    };
+    manifest.persistence = finalPersistence;
+    await atomicWrite(paths.manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+    written.manifest = true;
+    written.json = true;
+  } catch (error) {
+    writeErrors.push(error instanceof Error ? error.message : String(error));
+  }
+  if (written.manifest !== true) {
+    status = written.markdown === true ? "degraded" : "failed";
+    degradedReasons.push("manifest_persistence_failed");
+    manifest.status = status;
+    manifest.degradedReasons = [...new Set(degradedReasons)];
+  }
+  if (options.reconcile === true && options.variants.length >= 2 && answer.trim().length > 0 && written.manifest === true) {
+    const totalBudgetMs = options.timeoutMs ?? DEFAULT_FUSION_SYNTHESIS_TIMEOUT_MS;
+    const remainingBudgetMs = totalBudgetMs - (Date.now() - startedAt);
+    if (remainingBudgetMs <= 0) {
+      manifest.reconciliation = {
+        status: "skipped",
+        reason: "timeout_budget_exhausted"
+      };
+    } else {
+      const reconciliationOutput = await runAnalysisSynthesis({
+        taskId: options.taskId,
+        task: `${options.task}
+
+Already delivered Fusion answer (audit it; do not replace it):
+${answer}`,
+        variants: options.variants,
+        judge: {},
+        runSemantics: "fusion",
+        selectedTopN: options.variants.length,
+        synthesisModel: options.synthesisModel,
+        timeoutMs: remainingBudgetMs,
+        metadata: options.metadata,
+        artifactRootDir: path5.join(options.artifactRootDir, "reconciliation"),
+        workingDir: options.workingDir,
+        providerRunner: options.providerRunner
+      });
+      manifest.reconciliation = {
+        status: reconciliationOutput.result.status,
+        ...reconciliationOutput.paths.jsonPath ? {
+          jsonPath: formatAnalysisSynthesisArtifactPath(reconciliationOutput.paths.jsonPath)
+        } : {},
+        ...reconciliationOutput.paths.markdownPath ? {
+          markdownPath: formatAnalysisSynthesisArtifactPath(
+            reconciliationOutput.paths.markdownPath
+          )
+        } : {}
+      };
+    }
+    manifest.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      await atomicWrite(paths.manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+    } catch (error) {
+      writeErrors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  const persistence = persistenceFromWritten(written, writeErrors, persistenceExpected);
+  manifest.persistence = persistence;
+  const result = buildCompatibilityResult({
+    status,
+    answer,
+    inputs,
+    provenance,
+    persistence,
+    ...inputTruncation ? { inputTruncation } : {},
+    ...written.markdown ? { answerPath: formatAnalysisSynthesisArtifactPath(paths.answerPath) } : {},
+    ...errorMessage ? { error: errorMessage } : {}
+  });
+  return {
+    result,
+    manifest,
+    paths: {
+      ...written.markdown ? { answerPath: paths.answerPath } : {},
+      ...written.manifest ? { manifestPath: paths.manifestPath } : {},
+      ...written.prompt ? { promptPath: paths.promptPath } : {},
+      ...written.rawResponse ? { rawResponsePath: paths.rawResponsePath } : {}
+    },
+    persistence
+  };
+}
+
+// src/cli/handlers/compete/execute-competition-synthesis.ts
+function resolveAnalysisSynthesisArtifactRoot(buildDir, resolver = LabPathResolver.getInstance()) {
+  const labContext = resolver.getContext();
+  if (labContext) {
+    return path6.join(
+      resolveLabsRoot(buildDir),
+      labContext.labId,
+      "runs",
+      labContext.runId,
+      "analysis-synthesis"
+    );
+  }
+  return path6.join(buildDir, "analysis-synthesis");
+}
+var HOST_STATE_STATUS_TIMEOUT_MS = 5e3;
+var HOST_STATE_MAX_LINES = 80;
+var HOST_STATE_MAX_CHARS = 8e3;
+function sanitizeHostStateCwd(cwd) {
+  const basename2 = path6.basename(path6.resolve(cwd));
+  return basename2.length > 0 ? basename2 : ".";
+}
+function boundHostGitStatus(stdout) {
+  const normalized = filterWorktreeRunSentinelStatusOutput(stdout ?? "").replace(/\r\n/g, "\n").trimEnd();
+  if (normalized.length === 0) return { text: "", truncated: false };
+  let truncated = false;
+  const lines = normalized.split("\n");
+  let selected = lines;
+  if (lines.length > HOST_STATE_MAX_LINES) {
+    selected = lines.slice(0, HOST_STATE_MAX_LINES);
+    truncated = true;
+  }
+  let text = selected.join("\n");
+  if (text.length > HOST_STATE_MAX_CHARS) {
+    text = text.slice(0, HOST_STATE_MAX_CHARS);
+    truncated = true;
+  }
+  return {
+    text: truncated ? `${text}
+[truncated]` : text,
+    truncated
+  };
+}
+async function defaultGitStatusRunner(cwd) {
+  return execa("git", ["status", "--porcelain=v1", "--branch"], {
+    cwd,
+    reject: false,
+    timeout: HOST_STATE_STATUS_TIMEOUT_MS
+  });
+}
+async function captureAnalysisSynthesisHostState(cwd, runner = defaultGitStatusRunner) {
+  const base = {
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    cwd: sanitizeHostStateCwd(cwd),
+    statusSource: "git-status-porcelain-branch"
+  };
+  try {
+    const result = await runner(cwd);
+    if (typeof result.exitCode === "number" && result.exitCode !== 0) {
+      return {
+        ...base,
+        captureError: sanitizeDiagnosticOutput(result.stderr || result.stdout, 600) ?? `git status exited ${result.exitCode}`
+      };
+    }
+    const bounded = boundHostGitStatus(result.stdout);
+    return {
+      ...base,
+      gitStatusPorcelainBranch: bounded.text,
+      ...bounded.truncated ? { gitStatusTruncated: true } : {}
+    };
+  } catch (error) {
+    return {
+      ...base,
+      captureError: sanitizeDiagnosticOutput(error instanceof Error ? error.message : String(error), 600) ?? "git status capture failed"
+    };
+  }
+}
+function hostStateHasUncommittedTrackedChanges(hostState) {
+  const status = hostState?.gitStatusPorcelainBranch;
+  if (!status) return false;
+  return status.split("\n").some((line) => {
+    if (line.length < 3 || line.startsWith("##") || line === "[truncated]") return false;
+    const code = line.slice(0, 2);
+    return code !== "??" && code !== "!!";
+  });
+}
+var FUSION_UNCOMMITTED_CHANGES_WARNING = "Warning: uncommitted changes to tracked files are not visible to peers, which analyze committed code only; the synthesizer reads the working tree.";
+function collectAnalysisSynthesisVariantInputs(variants) {
+  return variants.flatMap((variant) => {
+    if (variant.success !== true) return [];
+    const outputText = resolveVariantContributedText(variant);
+    if (outputText.trim().length === 0) return [];
+    const input = {
+      variantId: getCanonicalVariantKeyFromResultWithInstance(variant),
+      provider: variant.provider,
+      output: outputText
+    };
+    const resolvedModel = variant.resolvedModel ?? variant.model;
+    if (resolvedModel !== void 0) {
+      input.model = resolvedModel;
+    }
+    if (variant.researchTrace) {
+      input.researchTrace = variant.researchTrace;
+    }
+    return [input];
+  });
+}
+function coerceAnalysisSynthesisContributorError(value) {
+  if (typeof value === "string") return value;
+  if (value instanceof Error) return value.message;
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  for (const key of ["message", "error", "stderr", "reason"]) {
+    const candidate = record[key];
+    if (typeof candidate === "string" && candidate.trim().length > 0) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function getCanonicalVariantKeyFromResultWithInstance(variant) {
+  const canonicalKey = getCanonicalVariantKeyFromResult(variant);
+  return variant.variantInstanceId ? `${canonicalKey}:${variant.variantInstanceId}` : canonicalKey;
+}
+function resolveVariantContributedText(variant) {
+  return variant.result?.stdout ?? variant.output ?? "";
+}
+function hasUsableAnalysisOutput(variant) {
+  return variant.success === true && resolveVariantContributedText(variant).trim().length > 0;
+}
+function collectAnalysisSynthesisContributorHealth(variants) {
+  return variants.map((variant) => {
+    const outputText = resolveVariantContributedText(variant);
+    const variantId = getCanonicalVariantKeyFromResultWithInstance(variant);
+    const variantDiagnostics = variant;
+    const status = variant.success !== true ? "failed" : outputText.trim().length === 0 ? "empty_output" : "included";
+    const providerDiagnostics = normalizeProviderRunDiagnostics(
+      variant.providerDiagnostics ?? variantDiagnostics.result?.providerDiagnostics
+    );
+    const stderrSeverity = providerDiagnostics?.stderrSeverity;
+    const stderrIsExplicitlyNonFatal = stderrSeverity === "none" || stderrSeverity === "info" || stderrSeverity === "warning";
+    const includeStderrAsError = providerDiagnosticsReportFatalRuntimeIssue(providerDiagnostics) || status !== "included" && !stderrIsExplicitlyNonFatal;
+    const researchCitationCount = variant.researchTrace?.citations.length;
+    const researchTraceStatus = variant.researchTrace?.status;
+    const researchExcludedDomainViolations = variant.researchTrace?.citations.filter(
+      (citation) => citation.excludedDomainViolation === true
+    ).length;
+    const error = [
+      variantDiagnostics.error,
+      variantDiagnostics.errorMessage,
+      variantDiagnostics.result?.error,
+      includeStderrAsError ? variantDiagnostics.result?.stderr : void 0
+    ].map(coerceAnalysisSynthesisContributorError).find((candidate) => candidate && candidate.trim().length > 0);
+    const renderedError = sanitizeAnalysisSynthesisContributorError(error);
+    return {
+      variantId,
+      provider: variant.provider,
+      ...variant.resolvedModel ?? variant.model ? { model: variant.resolvedModel ?? variant.model } : {},
+      status,
+      success: variant.success,
+      outputChars: outputText.length,
+      ...renderedError ? { error: renderedError } : {},
+      ...researchCitationCount !== void 0 ? { researchCitationCount } : {},
+      ...researchTraceStatus !== void 0 ? { researchTraceStatus } : {},
+      ...variant.researchTrace?.observedWebToolEvent !== void 0 ? { researchObservedWebToolEvent: variant.researchTrace.observedWebToolEvent } : {},
+      ...researchExcludedDomainViolations !== void 0 ? { researchExcludedDomainViolations } : {},
+      ...variant.researchTrace?.artifactPath ? { researchTracePath: variant.researchTrace.artifactPath } : {}
+    };
+  });
+}
+function maybeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function deriveResearchGroundingDegraded(variants, researchEnabled, researchMode) {
+  if (!researchEnabled || researchMode !== "native") return false;
+  const clearedPeers = variants.filter((v) => v.researchTrace != null);
+  if (clearedPeers.length === 0) return false;
+  return clearedPeers.some((v) => v.researchTrace?.observedWebToolEvent !== true);
+}
+function buildAnalysisSynthesisJudgeSummary(input) {
+  if (input.omitWinnerFraming) {
+    return {};
+  }
+  const summary = {
+    winner: input.winner ? getCanonicalVariantKeyFromResult(input.winner) : null
+  };
+  const confidence = maybeNumber(input.winner?.judgeEvaluation?.confidence);
+  if (confidence !== void 0) summary.confidence = confidence;
+  const rankings = input.judgeContext?.rankedVariants.map((variant) => {
+    const ranking = {
+      variantId: variant.variantId,
+      provider: variant.provider
+    };
+    if (variant.selectedJudgeRank !== void 0) ranking.rank = variant.selectedJudgeRank;
+    if (variant.selectedJudgeScore !== void 0) ranking.score = variant.selectedJudgeScore;
+    return ranking;
+  });
+  if (rankings && rankings.length > 0) summary.rankings = rankings;
+  const reasoning = input.winner?.winnerSelectionReason ?? input.judgeContext?.rationale?.selectedJudgeReason ?? input.judgeContext?.rationale?.baseSelectionReason;
+  if (reasoning) summary.reasoning = reasoning;
+  return summary;
+}
+function formatFusionReconciliationLine(reconciliation) {
+  if (reconciliation.markdownPath) return `Fusion reconciliation: ${reconciliation.markdownPath}`;
+  const reason = reconciliation.reason ? ` (${reconciliation.reason.replaceAll("_", " ")})` : "";
+  return `Fusion reconciliation: ${reconciliation.status}${reason}; no report written`;
+}
+async function executeCompetitionSynthesis(params) {
+  const {
+    winner,
+    variants,
+    synthesisJudgeContext,
+    aiJudgeRequested,
+    isFusionRun,
+    executionIntentEffective,
+    taskId,
+    task,
+    taskLabelSource,
+    analysisSynthesis,
+    synthesisTopN,
+    synthesisModel,
+    fusionReconcile,
+    timeoutMs,
+    researchRequested,
+    researchEnabled,
+    researchMode,
+    researchPacketPath,
+    researchExcludeDomain,
+    hostStateCapturer,
+    output
+  } = params;
+  const analysisSynthesisExpected = shouldRunAnalysisSynthesisStage({
+    analysisSynthesis,
+    executionIntentEffective
+  }) && (aiJudgeRequested || isFusionRun);
+  if (!analysisSynthesisExpected) {
+    return { analysisSynthesisExpected };
+  }
+  const analysisSynthesisInputs = collectAnalysisSynthesisVariantInputs(variants);
+  const contributorHealth = collectAnalysisSynthesisContributorHealth(variants);
+  const synthesisWorkingDir = process.cwd();
+  const hostState = await (hostStateCapturer ?? captureAnalysisSynthesisHostState)(
+    synthesisWorkingDir
+  );
+  const researchGroundingDegraded = deriveResearchGroundingDegraded(
+    variants,
+    researchEnabled,
+    researchMode
+  );
+  if (researchGroundingDegraded) {
+    const countResearchClearedPeers = variants.filter((v) => v.researchTrace != null).length;
+    const countGrounded = variants.filter(
+      (v) => v.researchTrace?.observedWebToolEvent === true
+    ).length;
+    const ungrounded = countResearchClearedPeers - countGrounded;
+    output.line(
+      `Warning: research requested but ${ungrounded} of ${countResearchClearedPeers} peers produced no observed web/MCP tool events (grounding degraded).`
+    );
+  }
+  if (isFusionRun && hostStateHasUncommittedTrackedChanges(hostState)) {
+    output.line(FUSION_UNCOMMITTED_CHANGES_WARNING);
+  }
+  if (isFusionRun) {
+    output.event(infoEvent("Fusion synthesis: integrating contributor outputs"));
+  }
+  const metadata = {
+    task: {
+      label: taskLabelSource,
+      intent: executionIntentEffective,
+      runSemantics: isFusionRun ? "fusion" : "analysis"
+    },
+    research: {
+      requested: researchRequested,
+      enabled: researchEnabled,
+      mode: researchEnabled && researchMode ? researchMode : void 0,
+      packetPath: researchPacketPath,
+      excludedDomains: researchExcludeDomain
+    },
+    contributorHealth,
+    hostState
+  };
+  const labResolver = LabPathResolver.getInstance();
+  const isLabRun = labResolver.getContext() !== null;
+  const artifactRootDir = resolveAnalysisSynthesisArtifactRoot(
+    getExecutionContext().buildDir,
+    labResolver
+  );
+  const analysisSynthesis_ = isFusionRun ? await runFusionSynthesis({
+    taskId,
+    task,
+    variants: analysisSynthesisInputs,
+    synthesisModel,
+    reconcile: fusionReconcile === true,
+    isLabRun,
+    timeoutMs,
+    metadata,
+    artifactRootDir,
+    workingDir: synthesisWorkingDir
+  }) : await runAnalysisSynthesis({
+    taskId,
+    task,
+    variants: analysisSynthesisInputs,
+    judge: buildAnalysisSynthesisJudgeSummary({
+      winner,
+      judgeContext: synthesisJudgeContext
+    }),
+    runSemantics: "analysis",
+    selectedTopN: synthesisTopN ?? 3,
+    synthesisModel,
+    timeoutMs,
+    metadata,
+    artifactRootDir,
+    workingDir: synthesisWorkingDir
+  });
+  const analysisSynthesisContributors = (analysisSynthesis_.result.inputs?.variants ?? analysisSynthesisInputs).map((variant) => variant.variantId);
+  const deliveredMarkdownPath = isFusionRun ? "answerPath" in analysisSynthesis_.paths ? analysisSynthesis_.paths.answerPath : void 0 : "markdownPath" in analysisSynthesis_.paths ? analysisSynthesis_.paths.markdownPath : void 0;
+  const deliveredJsonPath = isFusionRun ? "manifestPath" in analysisSynthesis_.paths ? analysisSynthesis_.paths.manifestPath : void 0 : "jsonPath" in analysisSynthesis_.paths ? analysisSynthesis_.paths.jsonPath : void 0;
+  const fusionReconciliationLine = "manifest" in analysisSynthesis_ && analysisSynthesis_.manifest.reconciliation ? formatFusionReconciliationLine(analysisSynthesis_.manifest.reconciliation) : void 0;
+  if (!isFusionRun && deliveredMarkdownPath) {
+    output.line(formatAnalysisSynthesisPathLine(deliveredMarkdownPath));
+  }
+  return {
+    analysisSynthesisExpected,
+    analysisSynthesisMarkdownPath: deliveredMarkdownPath,
+    analysisSynthesisJsonPath: deliveredJsonPath,
+    ...fusionReconciliationLine ? { fusionReconciliationLine } : {},
+    analysisSynthesisStatus: analysisSynthesis_.result.status,
+    analysisSynthesisResult: analysisSynthesis_.result,
+    analysisSynthesisContributors,
+    ...researchGroundingDegraded ? { researchGroundingDegraded: true } : {}
+  };
+}
+
+// src/cli/handlers/compete/compete-terminal-exit.ts
+function formatSucceededVariants(successCount, totalVariantCount) {
+  return `${successCount} of ${totalVariantCount} variant${totalVariantCount === 1 ? "" : "s"} succeeded`;
+}
+function noWinnerExit(successCount, totalVariantCount, reason) {
+  if (reason === "all_variants_failed") {
+    return { code: 1, message: "No variants succeeded", noWinnerReason: reason };
+  }
+  const why = reason === "judge_picked_none" ? "the judge picked no winner" : "none was verification-backed";
+  return {
+    code: 1,
+    message: `${formatSucceededVariants(successCount, totalVariantCount)}; ${why}; nothing was applied.`,
+    noWinnerReason: reason
+  };
+}
+var DEFAULT_BEST_EFFORT_REQUIRED_GATE_POLICY = "build-only";
+function resolveEffectiveRequiredGatePolicy(requiredGatePolicy) {
+  return requiredGatePolicy ?? DEFAULT_BEST_EFFORT_REQUIRED_GATE_POLICY;
+}
+var COMPETE_DELIVERY_ROUTE_TERMINAL_SEMANTICS = Object.freeze({
+  basic: Object.freeze({
+    route: "basic",
+    finishLine: "local",
+    summary: "local",
+    handoff: "local",
+    statePersistence: "local",
+    apply: "local",
+    terminalExit: "delivery-aware",
+    finalOutcomeSource: "basic-finalization"
+  }),
+  background: Object.freeze({
+    route: "background",
+    finishLine: "worker",
+    summary: "none",
+    handoff: "none",
+    statePersistence: "worker",
+    apply: "none",
+    terminalExit: "accepted",
+    finalOutcomeSource: "background-worker"
+  })
+});
+function isFailedOrUnavailableVerificationStatus(value) {
+  return value === "failed" || value === "error" || value === "timeout" || value === "unavailable";
+}
+function hasExplicitVerificationFailureEvidence(variant) {
+  if (!variant) return false;
+  const outcomeVerification = variant.outcome?.verification;
+  const nonLintGateStatuses = [
+    outcomeVerification?.buildStatus,
+    outcomeVerification?.buildOutcome,
+    outcomeVerification?.testStatus,
+    outcomeVerification?.testOutcome,
+    variant.buildStatus,
+    variant.testStatus
+  ];
+  const hasNonLintGateFailure = nonLintGateStatuses.some(isFailedOrUnavailableVerificationStatus);
+  if (hasNonLintGateFailure) {
+    return true;
+  }
+  if (hasVetoingUnavailableVerificationGateEvidence({
+    testStatus: variant.testStatus,
+    testsExecuted: variant.testsExecuted,
+    verificationLoop: variant.verificationLoop
+  })) {
+    return true;
+  }
+  const lintFailed = outcomeVerification?.lintStatus === "failed" || variant.lintStatus === "failed";
+  if (!lintFailed && (outcomeVerification?.status === "failed" || outcomeVerification?.deterministicGatesPassed === false)) {
+    return true;
+  }
+  if (variant.verification?.passed === false) {
+    const findings = variant.verification.findings ?? [];
+    if (findings.length > 0 && findings.some((finding) => finding.kind !== "lint")) {
+      return true;
+    }
+  }
+  const testExitCode = variant.testsExecuted?.exitCode;
+  return typeof testExitCode === "number" && testExitCode !== 0;
+}
+function hasNonEmptyEditEvidence(variant) {
+  if (variant.emptyChanges === false) return true;
+  if (typeof variant.worktreeDiff === "string" && variant.worktreeDiff.trim().length > 0) {
+    return true;
+  }
+  return (variant.filesChanged ?? 0) > 0 || (variant.linesAdded ?? 0) > 0 || (variant.linesRemoved ?? 0) > 0 || (variant.workspaceEditsApplied ?? 0) > 0 || (variant.gitMetrics?.filesChanged ?? 0) > 0 || (variant.gitMetrics?.linesAdded ?? 0) > 0 || (variant.gitMetrics?.linesDeleted ?? 0) > 0 || (variant.worktreeSummary?.filesChanged ?? 0) > 0 || (variant.worktreeSummary?.insertions ?? 0) > 0 || (variant.worktreeSummary?.deletions ?? 0) > 0 || hasIgnoredPlanningArtifactEvidence(variant);
+}
+function getIgnoredPlanningArtifactCount(variant) {
+  const paths = variant.ignoredPathEvidence?.paths;
+  if (!Array.isArray(paths)) return 0;
+  return paths.filter(isIgnoredPlanningArtifactPath).length;
+}
+function countVariantFilesChanged(variant) {
+  return Math.max(
+    variant.filesChanged ?? 0,
+    variant.gitMetrics?.filesChanged ?? 0,
+    variant.worktreeSummary?.filesChanged ?? 0
+  );
+}
+function formatVariantChangeSummary(variant, options = {}) {
+  const filesChanged = countVariantFilesChanged(variant);
+  if (options.editsExpected === false) {
+    return filesChanged > 0 ? `${filesChanged} file${filesChanged !== 1 ? "s" : ""} changed` : "no edits";
+  }
+  const edits = variant.workspaceEditsApplied ?? 0;
+  if (edits > 0) return `${edits} edit${edits !== 1 ? "s" : ""}`;
+  if (filesChanged > 0) {
+    return `${filesChanged} file${filesChanged !== 1 ? "s" : ""} changed`;
+  }
+  const ignoredPlanningArtifacts = getIgnoredPlanningArtifactCount(variant);
+  return ignoredPlanningArtifacts > 0 ? `${ignoredPlanningArtifacts} planning artifact${ignoredPlanningArtifacts !== 1 ? "s" : ""}` : "no edits";
+}
+function hasNonEmptyEditDelivery(variant) {
+  return variant.success === true && hasNonEmptyEditEvidence(variant);
+}
+function hasSuccessfulCompetitionDelivery(result) {
+  return Boolean(result.winner) || result.variants?.some((variant) => variant.success) === true;
+}
+function shouldFailForEmptyEditDelivery(result) {
+  if (result.editsExpected !== true || !Array.isArray(result.variants)) return false;
+  const completedVariants = result.variants.filter((variant) => variant.success === true);
+  if (completedVariants.length > 0) {
+    return !completedVariants.some(hasNonEmptyEditDelivery);
+  }
+  return result.variants.length > 0;
+}
+function formatEmptyEditDeliveryWarning(result) {
+  return result.variants?.some((variant) => variant.success === true) ? "Delivery failed: completed variants produced no edits; judge winner retained." : "Delivery failed: no variant completed, so there is no winner and nothing was applied.";
+}
+function resolveCompetitionDeliveryExit(result) {
+  const variants = Array.isArray(result.variants) ? result.variants : [];
+  const totalVariantCount = variants.length;
+  const verifiedVariantCount = Math.max(0, result.verifiedVariantCount);
+  const successCount = variants.filter((v) => v.success === true).length;
+  const hasFailure = variants.some((v) => v.success !== true);
+  if (shouldFailForEmptyEditDelivery(result)) {
+    const noWinnerReason = successCount === 0 ? "all_variants_failed" : "no_edits";
+    return {
+      code: 1,
+      message: successCount === 0 ? "No variants succeeded" : "No variants produced edits",
+      ...result.winner ? {} : { noWinnerReason }
+    };
+  }
+  if (result.winner) {
+    const explicitlyFailedWinnerVerification = result.winnerVerified === false && (result.deliveryVerificationMode === "required" || result.deliveryVerificationMode === "best_effort" && hasExplicitVerificationFailureEvidence(result.winner));
+    if (explicitlyFailedWinnerVerification) {
+      return {
+        code: 3,
+        message: "Competition degraded: selected winner was not verification-backed"
+      };
+    }
+    if (hasFailure) {
+      return {
+        code: 3,
+        message: `Competition degraded: ${successCount}/${totalVariantCount} variants completed`
+      };
+    }
+    return { code: 0, message: "Competition completed successfully" };
+  }
+  if (result.deliveryVerificationMode === "not_applicable" || result.deliveryVerificationMode === "best_effort") {
+    if (successCount === 0) {
+      return noWinnerExit(successCount, totalVariantCount, "all_variants_failed");
+    }
+    if (successCount < totalVariantCount) {
+      return {
+        code: 2,
+        message: "Competition completed with partial variant failures"
+      };
+    }
+    return { code: 0, message: "Competition completed successfully" };
+  }
+  if (totalVariantCount > 0 && verifiedVariantCount >= totalVariantCount && hasSuccessfulCompetitionDelivery(result)) {
+    return { code: 0, message: "Competition completed successfully" };
+  }
+  if (verifiedVariantCount > 0) {
+    return {
+      code: 2,
+      message: "Competition completed with partial variant failures"
+    };
+  }
+  return noWinnerExit(
+    successCount,
+    totalVariantCount,
+    successCount === 0 ? "all_variants_failed" : "no_verified_variant"
+  );
+}
+var SYNTHESIS_STATUS_SEVERITY = {
+  succeeded: 0,
+  applied: 0,
+  skipped: 0,
+  no_pick: 0,
+  winner_carry_forward: 0,
+  partial: 1,
+  degraded: 1,
+  failed: 2,
+  generation_failed: 2,
+  gate_failed: 2,
+  timed_out: 2,
+  editable_workspace_unavailable: 2,
+  not_attempted: 2
+};
+function pickWorseSynthesisStatus(left, right) {
+  if (left == null || left === "") return right;
+  if (right == null || right === "") return left;
+  const leftSeverity = SYNTHESIS_STATUS_SEVERITY[left] ?? 2;
+  const rightSeverity = SYNTHESIS_STATUS_SEVERITY[right] ?? 2;
+  return rightSeverity > leftSeverity ? right : left;
+}
+function resolveAnalysisSynthesisDeliveryExit(deliveryExit, options) {
+  if (options.synthesisExpected !== true) {
+    return deliveryExit;
+  }
+  const status = options.analysisSynthesisStatus;
+  if (status === "succeeded") {
+    return deliveryExit;
+  }
+  if (status === "partial" || status === "degraded") {
+    if (deliveryExit.code === 0) {
+      return {
+        code: 3,
+        message: status === "degraded" ? "Competition degraded: analysis synthesis completed with degraded output" : "Competition degraded: analysis synthesis completed with partial inputs"
+      };
+    }
+    return deliveryExit;
+  }
+  if (status === "failed" || status === "generation_failed" || status === "gate_failed" || status === "timed_out" || status === "editable_workspace_unavailable" || status === "not_attempted" || options.fusionRun === true && !status) {
+    if (options.fusionRun === true) {
+      return { code: 1, message: "Fusion synthesis failed" };
+    }
+    if (deliveryExit.code === 0) {
+      return {
+        code: 3,
+        message: "Competition degraded: synthesis failed"
+      };
+    }
+  }
+  return deliveryExit;
+}
+function formatCompetitionDeliveryResultLabel(deliveryExit, options) {
+  if (options?.judgeOffMultiVariant && deliveryExit.code !== 0) return "incomplete";
+  if (deliveryExit.code === 0) return "success";
+  if (deliveryExit.code === 3) return "degraded";
+  if (deliveryExit.code === 2) return "partial";
+  return "failed";
+}
+function formatJudgeOffVariantStatus(input) {
+  return input.success ? "completed, ungraded" : "failed";
+}
+function isJudgeOffMultiVariantWithoutWinner(input) {
+  return input.judge === "off" && input.variantCount > 1 && !input.winner;
+}
+function resolveJudgeOffMultiVariantDeliveryExit(result) {
+  const code = result !== void 0 ? resolveCompetitionDeliveryExit({
+    winner: null,
+    variants: result.variants,
+    verifiedVariantCount: result.variants?.filter((variant) => variant.success === true).length ?? 0,
+    deliveryVerificationMode: result.deliveryVerificationMode ?? "best_effort",
+    editsExpected: result.editsExpected
+  }).code : 0;
+  const message = code === 0 ? "Comparison completed without winner (--judge off); inspect variants or rerun with one --variant / enable judge" : "Comparison incomplete without winner (--judge off); inspect failed variants or rerun with one --variant / enable judge";
+  return {
+    code,
+    message
+  };
+}
+function resolveFusionDeliveryExit(input) {
+  if (input.fusionRun !== true) return null;
+  const status = input.analysisSynthesisStatus ?? "not_produced";
+  if (input.synthesisContributorCount === 0) {
+    return {
+      code: 1,
+      message: "Fusion failed: no contributors produced usable analysis"
+    };
+  }
+  if (input.synthesisContributorCount < 2) {
+    return {
+      code: 3,
+      message: `Fusion degraded: only ${input.synthesisContributorCount}/${input.totalVariantCount} contributors produced usable analysis; no multi-source fusion was produced`
+    };
+  }
+  if (status === "partial") {
+    return {
+      code: 3,
+      message: "Fusion degraded: synthesis completed with partial contributor coverage"
+    };
+  }
+  if (status === "degraded") {
+    return {
+      code: 3,
+      message: "Fusion degraded: synthesis completed with degraded output"
+    };
+  }
+  if (status !== "succeeded") {
+    return {
+      code: 1,
+      message: `Fusion failed: synthesis status ${status}`
+    };
+  }
+  return null;
+}
+function computeCompetitionTerminalExit(input) {
+  const variants = input.fusionRun === true && Array.isArray(input.variants) ? input.variants.map(
+    (variant) => variant.success === true && !hasUsableAnalysisOutput(variant) ? { ...variant, success: false } : variant
+  ) : input.variants;
+  let deliveryExit = resolveCompetitionDeliveryExit({
+    winner: input.winner,
+    variants,
+    verifiedVariantCount: input.verifiedVariantCount,
+    winnerVerified: input.winnerVerified,
+    deliveryVerificationMode: input.deliveryVerificationMode,
+    editsExpected: input.editsExpected
+  });
+  if (input.judgeOffMultiVariant) {
+    deliveryExit = resolveJudgeOffMultiVariantDeliveryExit({
+      variants,
+      deliveryVerificationMode: input.deliveryVerificationMode,
+      editsExpected: input.editsExpected
+    });
+  }
+  if (input.judgedNoWinner === true && !input.winner) {
+    const total = Array.isArray(variants) ? variants.length : 0;
+    const completed = Array.isArray(variants) ? variants.filter((variant) => variant.success === true).length : 0;
+    if (completed > 0 && (deliveryExit.code !== 1 || deliveryExit.noWinnerReason === "no_verified_variant")) {
+      deliveryExit = noWinnerExit(completed, total, "judge_picked_none");
+    }
+  }
+  if (input.fusionRun === true) {
+    const fusionDeliveryExit = resolveFusionDeliveryExit({
+      fusionRun: true,
+      synthesisContributorCount: input.synthesisContributorCount ?? 0,
+      totalVariantCount: Array.isArray(variants) ? variants.length : 0,
+      analysisSynthesisStatus: input.analysisSynthesisStatus
+    });
+    if (fusionDeliveryExit) {
+      deliveryExit = fusionDeliveryExit;
+    }
+  } else {
+    deliveryExit = resolveAnalysisSynthesisDeliveryExit(deliveryExit, {
+      synthesisExpected: input.synthesisExpected,
+      fusionRun: input.fusionRun,
+      analysisSynthesisStatus: input.analysisSynthesisStatus
+    });
+  }
+  return deliveryExit;
+}
+
+// src/cli/handlers/compete/run-summary-display.ts
+function getRequiredGateAwareDisplayVerdict(variant, options = {}) {
+  return getDisplayVerificationVerdict(variant, {
+    requiredGatePolicy: resolveEffectiveRequiredGatePolicy(options.requiredGatePolicy)
+  });
+}
+function getUnanimousMatrixWinner(matrixResult) {
+  if (matrixResult?.winnerStatus === "inconclusive") return null;
+  const winners = matrixResult?.profileVerdicts.map((verdict) => verdict.winner.trim());
+  if (!winners || winners.length < 2 || winners.some((winner) => winner.length === 0)) {
+    return null;
+  }
+  const [firstWinner, ...remainingWinners] = winners;
+  if (!firstWinner || remainingWinners.some((winner) => winner !== firstWinner)) {
+    return null;
+  }
+  return firstWinner;
+}
+function formatMatrixPrimaryDisagreementSummary(input) {
+  const matrixWinner = getUnanimousMatrixWinner(input.matrixResult);
+  const primaryWinnerDisplay = formatVariantKeyForDisplay(input.primaryWinner);
+  const matrixWinnerDisplay = matrixWinner ? formatVariantKeyForDisplay(matrixWinner) : null;
+  if (!matrixWinnerDisplay || matrixWinnerDisplay === primaryWinnerDisplay) return null;
+  if (!isNearTieMargin({ margin: input.margin, threshold: input.threshold })) return null;
+  const marginLabel = typeof input.margin === "number" && Number.isFinite(input.margin) ? input.margin.toFixed(1) : "n/a";
+  return `matrixPrimaryDisagreement: primary=${primaryWinnerDisplay} matrix=${matrixWinnerDisplay} margin=${marginLabel}`;
+}
+function resolveMatrixDisagreementPrimary(input) {
+  if (input.winnerSelectionSource !== "matrix-verdict") return input.winnerLabel;
+  const original = input.aiRankedFirst?.trim() || input.multiJudgePrimaryWinner?.trim();
+  return original ? original : input.winnerLabel;
+}
+function resolveJudgeRequestedLabel(input) {
+  if (input.effectiveJudge === "off") return "off";
+  if (input.aiJudgePrimary) return input.aiJudgePrimary;
+  if (input.effectiveJudge && input.effectiveJudge !== "auto") return input.effectiveJudge;
+  return input.aiJudgeRequested ? "ai" : void 0;
+}
+function renderRepairOutcomeRunSummary(winner) {
+  const repairOutcome = winner?.repairOutcome;
+  if (!repairOutcome) return [];
+  const lines = [
+    `repairAttempted: ${repairOutcome.attempted}`,
+    `repairClassification: ${repairOutcome.classification ?? "unknown"}`,
+    `judgeVerdictApplicability: ${repairOutcome.judgeVerdictApplicability ?? "unknown"}`,
+    `finalArtifactTrust: ${repairOutcome.finalArtifactTrust ?? "unknown"}`
+  ];
+  if (repairOutcome.repairTrigger?.type) {
+    lines.push(`repairTrigger: ${repairOutcome.repairTrigger.type}`);
+  }
+  const delta = repairOutcome.repairDelta;
+  if (delta) {
+    lines.push(`repairFilesOutsidePreRepairDiff: ${delta.filesOutsidePreRepairDiff.length}`);
+    lines.push(`repairLineDeltaRatio: ${delta.lineDeltaRatio.toFixed(3)}`);
+  }
+  if (repairOutcome.judgeVerdictApplicability === "does_not_apply") {
+    lines.push("judgeVerdictAppliesToFinalArtifact: false");
+  }
+  return lines;
+}
+function scoreForVariantFromTop2(top2Summary, variant) {
+  if (!top2Summary || typeof variant !== "string" || variant.trim().length === 0) {
+    return null;
+  }
+  const target = formatVariantKeyForDisplay(variant);
+  const entry = top2Summary.top2.find(
+    (candidate) => formatVariantKeyForDisplay(candidate.variant) === target
+  );
+  return entry ? entry.score : null;
+}
+function scoreForRunSummaryPrimary(input) {
+  if (typeof input.multiJudgeRun?.primary_winner_score === "number" && Number.isFinite(input.multiJudgeRun.primary_winner_score) && typeof input.multiJudgeRun.primary_winner === "string" && typeof input.primaryWinner === "string" && variantHandlesMatchForResults(input.multiJudgeRun.primary_winner, input.primaryWinner)) {
+    return input.multiJudgeRun.primary_winner_score;
+  }
+  return scoreForVariantFromTop2(input.top2Summary, input.primaryWinner);
+}
+function formatRunSummaryScoreCalibration(input) {
+  const lines = [];
+  const primaryWinner = typeof input.primaryWinner === "string" && input.primaryWinner.trim().length > 0 ? input.primaryWinner : null;
+  const finalWinner = input.finalWinner;
+  const primaryWinnerDisplay = primaryWinner ? formatVariantKeyForDisplay(primaryWinner) : null;
+  const finalWinnerDisplay = formatVariantKeyForDisplay(finalWinner);
+  const winnersDiffer = primaryWinnerDisplay != null && primaryWinnerDisplay !== finalWinnerDisplay;
+  const scoreDelta = typeof input.primaryScore === "number" && Number.isFinite(input.primaryScore) && typeof input.finalScore === "number" && Number.isFinite(input.finalScore) ? input.primaryScore - input.finalScore : null;
+  if (primaryWinnerDisplay && (winnersDiffer || scoreDelta != null && Math.abs(scoreDelta) >= 0.1)) {
+    lines.push(`judgePrimaryWinner: ${primaryWinnerDisplay}`);
+    if (typeof input.primaryScore === "number" && Number.isFinite(input.primaryScore)) {
+      lines.push(`judgePrimaryScore: ${input.primaryScore.toFixed(1)}`);
+    }
+    lines.push(`finalRetainedWinner: ${finalWinnerDisplay}`);
+    if (typeof input.finalScore === "number" && Number.isFinite(input.finalScore)) {
+      lines.push(`finalRetainedScore: ${input.finalScore.toFixed(1)}`);
+    }
+    if (scoreDelta != null) {
+      lines.push(`scoreDeltaPrimaryFinal: ${scoreDelta.toFixed(1)}`);
+    }
+  }
+  return lines;
+}
+function isPricedRunSummaryCost(metrics) {
+  if (!metrics) return false;
+  if (metrics.usageUnavailableReason === "provider_not_reported") return false;
+  if (metrics.pricingStatus === "unavailable" || metrics.pricingStatus === "error") return false;
+  return typeof metrics.totalCost === "number" && Number.isFinite(metrics.totalCost);
+}
+function formatKnownUsd(amount) {
+  const cents = Math.round(amount * 100) / 100;
+  if (Math.abs(amount - cents) < 1e-9) {
+    return `$${cents.toFixed(2)}`;
+  }
+  const tenThousandths = Math.round(amount * 1e4) / 1e4;
+  return `$${tenThousandths.toFixed(4)}`;
+}
+function resolveRunSummaryJudgeCostUsd(input) {
+  if (typeof input.judgeCostUsd === "number" && Number.isFinite(input.judgeCostUsd)) {
+    return input.judgeCostUsd;
+  }
+  const raw = input.latestMultiJudgeRun?.resultsJson ?? input.latestMultiJudgeRun?.results_json;
+  let entries = [];
+  if (typeof raw === "string" && raw.trim().length > 0) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object") {
+        entries = Object.values(parsed);
+      }
+    } catch {
+      entries = [];
+    }
+  } else if (raw && typeof raw === "object") {
+    entries = Object.values(raw);
+  }
+  const costs = entries.map((entry) => entry?.costUsd).filter((value) => typeof value === "number" && Number.isFinite(value));
+  if (costs.length === 0) {
+    return void 0;
+  }
+  return costs.reduce((sum, value) => sum + value, 0);
+}
+function formatRunSummaryCostLabel(input) {
+  const judgeCostUsd = resolveRunSummaryJudgeCostUsd(input);
+  const members = input.variants;
+  const priced = members.filter((variant) => isPricedRunSummaryCost(variant.costMetrics));
+  const unpricedCount = members.length - priced.length;
+  const pricedSum = priced.reduce((sum, variant) => {
+    const metrics = variant.costMetrics;
+    return sum + (isPricedRunSummaryCost(metrics) ? metrics.totalCost : 0);
+  }, 0);
+  const judgeCost = judgeCostUsd;
+  if (members.length === 0 && judgeCost === void 0) {
+    return "n/a";
+  }
+  const parts = [];
+  if (members.length > 0) {
+    parts.push(`${unpricedCount}/${members.length} variants unpriced`);
+  }
+  if (priced.length > 0) {
+    parts.push(`priced ${formatKnownUsd(pricedSum)} (${describeAggregateBasis(priced)})`);
+  }
+  if (input.analysisSynthesisResult) {
+    const cost = input.analysisSynthesisResult.provenance?.totalCostUsd;
+    parts.push(
+      typeof cost === "number" && Number.isFinite(cost) ? `synthesis ${formatKnownUsd(cost)}` : "synthesis unpriced"
+    );
+  }
+  if (judgeCost !== void 0) {
+    parts.push(`judge ${formatKnownUsd(judgeCost)}`);
+  }
+  if (parts.length === 0) {
+    return "n/a";
+  }
+  return `unavailable (${parts.join("; ")})`;
+}
+function describeAggregateBasis(variants, options = {}) {
+  const reported = variants.filter(
+    (variant) => variant.costMetrics?.costBasis === "provider_reported"
+  ).length;
+  return [
+    "API list price",
+    ...reported > 0 ? [`${reported}/${variants.length} variants provider-reported, no list price`] : [],
+    ...options.includesSynthesis ? ["synthesis provider-reported"] : []
+  ].join("; ");
+}
+function formatCompetitionRunSummaryCostLabel(input) {
+  const receiptLabel = input.receipt ? formatTaskReportCostLabel(input.receipt) : void 0;
+  if (receiptLabel) return receiptLabel;
+  if (input.costAggregate.status === "available" && typeof input.costAggregate.totalCost === "number") {
+    return `$${input.costAggregate.totalCost.toFixed(4)} (${describeAggregateBasis(input.variants, { includesSynthesis: input.analysisSynthesisResult != null })})`;
+  }
+  return formatRunSummaryCostLabel({
+    variants: input.variants,
+    analysisSynthesisResult: input.analysisSynthesisResult,
+    judgeCostUsd: extractJudgeUsageSummary(
+      input.synthesisResult
+    ).costUsd,
+    latestMultiJudgeRun: input.latestMultiJudgeRun
+  });
+}
+function formatRunSummaryConfidence(winner) {
+  const confidence = typeof winner?.judgeEvaluation?.confidence === "number" ? winner.judgeEvaluation.confidence : typeof winner?.judgeEvaluation?.metadata?.confidence === "number" ? winner.judgeEvaluation.metadata.confidence : void 0;
+  if (typeof confidence !== "number" || !Number.isFinite(confidence)) {
+    return "n/a";
+  }
+  const percent = confidence <= 1 ? confidence * 100 : confidence;
+  return `${percent.toFixed(0)}%`;
+}
+var SLOW_POST_PROVIDER_PHASE_MS = 3e4;
+function formatDurationMsForSummary(durationMs) {
+  return formatDurationSeconds(durationMs / 1e3);
+}
+function formatSlowPostProviderPhases(variant) {
+  const phases = variant.postProviderPhaseDurationsMs;
+  if (!phases) return null;
+  const slowPhases = Object.entries(phases).filter(
+    ([, durationMs]) => Number.isFinite(durationMs) && durationMs >= SLOW_POST_PROVIDER_PHASE_MS
+  ).sort(([, left], [, right]) => right - left).slice(0, 4);
+  if (slowPhases.length === 0) return null;
+  return slowPhases.map(([phase, durationMs]) => `${phase}=${formatDurationMsForSummary(durationMs)}`).join(" ");
+}
+function hasJudgeSynthesisSignal(input) {
+  return Boolean(input.top2Summary) || Boolean(input.winner?.judgeEvaluation);
+}
+function formatWinnerJudgeSignal(input) {
+  const confidence = formatRunSummaryConfidence(input.winner);
+  const parts = [`confidence=${confidence}`];
+  const top2Summary = input.top2Summary;
+  if (top2Summary) {
+    parts.push(`margin=${top2Summary.margin.toFixed(1)}`);
+    const entries = top2Summary.top2.slice(0, 2).map((entry) => {
+      const label = formatVariantKeyForDisplay(entry.variant);
+      const score = Number.isFinite(entry.score) ? entry.score.toFixed(1) : "n/a";
+      return `${label}(${score})`;
+    });
+    if (entries.length === 2) {
+      parts.push(`top2=${entries[0]} vs ${entries[1]}`);
+    } else if (entries.length === 1) {
+      parts.push(`top2=${entries[0]}`);
+    }
+  }
+  return parts.join(" ");
+}
+function normalizeSynthesisOutcomeStatus(synthesisResult) {
+  if (typeof synthesisResult?.synthesisOutcomeStatus === "string") {
+    return synthesisResult.synthesisOutcomeStatus;
+  }
+  if (synthesisResult?.synthesisApplied === true) return "applied";
+  if (synthesisResult?.winnerFallback === true) return "winner_carry_forward";
+  if (synthesisResult) return "not_attempted";
+  return "not_attempted";
+}
+function formatTracePick(variant) {
+  return variant && variant.trim().length > 0 ? formatVariantKeyForDisplay(variant) : "no_pick";
+}
+function unwrapTruncatedMultiJudgeResults(parsed) {
+  if (parsed.truncated === true && parsed.summary && typeof parsed.summary === "object" && !Array.isArray(parsed.summary)) {
+    return parsed.summary;
+  }
+  return parsed;
+}
+function parseMultiJudgeResultsJson(run) {
+  if (run?.resultsJson && typeof run.resultsJson === "object" && !Array.isArray(run.resultsJson)) {
+    return unwrapTruncatedMultiJudgeResults(run.resultsJson);
+  }
+  const resultsJson = run?.results_json ?? run?.resultsJson;
+  if (typeof resultsJson !== "string" || resultsJson.trim().length === 0) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(resultsJson);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+    return unwrapTruncatedMultiJudgeResults(parsed);
+  } catch {
+    return null;
+  }
+}
+function getMultiJudgePrimaryJudge(run) {
+  return run?.primary_judge ?? run?.primaryJudge ?? null;
+}
+function getMultiJudgePrimaryWinner(run) {
+  return run?.primary_winner ?? run?.primaryWinner ?? null;
+}
+function getMultiJudgeExecutedJudges(run) {
+  if (!run) return [];
+  if (Array.isArray(run.judgesExecuted)) return run.judgesExecuted;
+  const raw = run.judges_executed ?? run.judgesExecuted;
+  if (typeof raw !== "string" || raw.trim().length === 0) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) return parsed.filter((judge) => typeof judge === "string");
+  } catch {
+    return raw.split(",").map((judge) => judge.trim()).filter(Boolean);
+  }
+  return [];
+}
+function multiJudgeExecuted(run, judge) {
+  if (!run) return false;
+  const results = parseMultiJudgeResultsJson(run);
+  const result = results?.[judge];
+  if (result) return result.status !== "skipped";
+  if (getMultiJudgePrimaryJudge(run) === judge) return true;
+  return getMultiJudgeExecutedJudges(run).includes(judge);
+}
+function multiJudgeWinner(run, judge) {
+  const results = parseMultiJudgeResultsJson(run);
+  const winner = results?.[judge]?.winner;
+  if (typeof winner === "string") return winner;
+  if (results && Object.hasOwn(results, judge)) return null;
+  if (getMultiJudgePrimaryJudge(run) === judge) return getMultiJudgePrimaryWinner(run);
+  return void 0;
+}
+function multiJudgeSkipReason(run, judge) {
+  const entry = parseMultiJudgeResultsJson(run)?.[judge];
+  if (!entry || entry.status !== "skipped") return null;
+  if (typeof entry.skippedReason === "string" && entry.skippedReason.trim().length > 0) {
+    return entry.skippedReason.trim();
+  }
+  if (typeof entry.error === "string" && entry.error.trim().length > 0) {
+    return entry.error.trim().replace(/\s+/g, "_").slice(0, 80);
+  }
+  return "unspecified";
+}
+function formatJudgeTraceLine(input) {
+  const skipReason = multiJudgeSkipReason(input.run, input.judge);
+  if (skipReason) return `skipped:${skipReason}`;
+  if (input.fallbackExecuted || multiJudgeExecuted(input.run, input.judge)) {
+    return formatTracePick(input.pick);
+  }
+  return "not_run";
+}
+function formatFinalCompetitionDecisionTraceLines(input) {
+  const lines = ["decisionTrace:"];
+  const winnerSource = input.winner?.winnerSelectionSource;
+  const aiMultiJudgeWinner = multiJudgeWinner(input.latestMultiJudgeRun, "ai");
+  const aiPick = input.latestJudgeDecision?.aiRankedFirst ?? aiMultiJudgeWinner ?? (winnerSource === "ai-judge" || winnerSource === "ai-judge-ranking" ? input.latestJudgeDecision?.selectedVariant ?? input.winner?.variant : void 0);
+  const aiLine = formatJudgeTraceLine({
+    run: input.latestMultiJudgeRun,
+    judge: "ai",
+    pick: aiPick,
+    fallbackExecuted: Boolean(input.latestJudgeDecision)
+  });
+  lines.push(`decisionTrace.aiJudge: ${aiLine}`);
+  const multiLensWinner = multiJudgeWinner(input.latestMultiJudgeRun, "multi-lens") ?? (winnerSource === "multi-lens" || winnerSource === "multi-lens-ranking" ? input.latestJudgeDecision?.selectedVariant ?? input.winner?.variant : void 0);
+  const multiLensLine = formatJudgeTraceLine({
+    run: input.latestMultiJudgeRun,
+    judge: "multi-lens",
+    pick: multiLensWinner,
+    fallbackExecuted: winnerSource === "multi-lens" || winnerSource === "multi-lens-ranking"
+  });
+  lines.push(`decisionTrace.multiLens: ${multiLensLine}`);
+  if (input.autoMatrixResult) {
+    const matrixWinner = getUnanimousMatrixWinner(input.autoMatrixResult);
+    const matrixStatus = input.autoMatrixResult.winnerStatus ?? "accepted";
+    lines.push(
+      `decisionTrace.matrix: ${matrixWinner ? formatVariantKeyForDisplay(matrixWinner) : "no_recommendation"} (${matrixStatus})`
+    );
+  } else if (input.latestJudgeDecision?.matrixAutoRunFailure) {
+    lines.push(`decisionTrace.matrix: failed (${input.latestJudgeDecision.matrixAutoRunFailure})`);
+  } else {
+    lines.push("decisionTrace.matrix: not_run");
+  }
+  lines.push(`decisionTrace.synthesis: ${normalizeSynthesisOutcomeStatus(input.synthesisResult)}`);
+  return lines;
+}
+function gateSnapshotFromSynthesis(synthesisResult) {
+  if (synthesisResult?.synthesisGateResults) {
+    return synthesisResult.synthesisGateResults;
+  }
+  const legacy = synthesisResult?.gateResults;
+  return isSynthesisGateResultSnapshot(legacy) ? legacy : void 0;
+}
+function isSynthesisGateResultSnapshot(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.isEligible === "boolean" && typeof candidate.buildPassed === "boolean" && typeof candidate.lintPassed === "boolean" && typeof candidate.formatPassed === "boolean" && typeof candidate.buildStatus === "string" && typeof candidate.lintStatus === "string" && typeof candidate.testStatus === "string" && typeof candidate.formatStatus === "string";
+}
+function coverageLabel(coverageStatus) {
+  switch (coverageStatus) {
+    case "verified":
+      return "verified";
+    case "partially_verified":
+      return "partial";
+    case "skipped_no_command":
+      return "not_configured";
+    case "skipped_tool_unavailable":
+      return "unavailable";
+    case "skipped_not_relevant":
+      return "not_relevant";
+    case "unverified":
+      return "unverified";
+    default:
+      return "unknown";
+  }
+}
+function appendCoverageReason(parts, reason) {
+  if (reason && reason.trim().length > 0) {
+    parts.push(`reason=${reason.trim().replace(/\s+/g, " ")}`);
+  }
+}
+function formatSnapshotGateLine(input) {
+  const parts = [
+    `status=${input.status ?? "not_run"}`,
+    `coverage=${coverageLabel(input.coverageStatus)}`
+  ];
+  appendCoverageReason(parts, input.reason);
+  return `synthesisGate.${input.gate}: ${parts.join(" ")}`;
+}
+function variantGateStatus(winner, gate) {
+  return winner ? readVariantVerification(winner).gates[gate].status : "not_run";
+}
+function formatSynthesisGateTraceLines(input) {
+  const synthesisResult = input.synthesisResult;
+  const outcomeStatus = normalizeSynthesisOutcomeStatus(synthesisResult);
+  const snapshot = gateSnapshotFromSynthesis(synthesisResult);
+  if (outcomeStatus === "winner_carry_forward" || synthesisResult?.winnerFallback === true) {
+    const lines = [
+      "synthesisGateSource: carried_forward_winner",
+      `synthesisGate.buildTypecheck: status=${variantGateStatus(input.winner, "build")} coverage=carried_forward`,
+      `synthesisGate.lint: status=${variantGateStatus(input.winner, "lint")} coverage=carried_forward`,
+      `synthesisGate.test: status=${variantGateStatus(input.winner, "test")} coverage=carried_forward`
+    ];
+    if (input.winner?.outcome?.verification?.status === "baseline_clean") {
+      lines.push("synthesisGateWinnerVerification: baseline_clean");
+    }
+    return lines;
+  }
+  if (!snapshot) {
+    const reason = synthesisResult ? "post-synthesis gate snapshot unavailable" : "synthesis not attempted";
+    return [
+      "synthesisGateSource: not_run",
+      `synthesisGate.buildTypecheck: status=not_run coverage=unknown reason=${reason}`,
+      `synthesisGate.lint: status=not_run coverage=unknown reason=${reason}`,
+      `synthesisGate.test: status=not_run coverage=unknown reason=${reason}`
+    ];
+  }
+  return [
+    "synthesisGateSource: synthesis_worktree",
+    formatSnapshotGateLine({
+      gate: "buildTypecheck",
+      status: snapshot.buildStatus,
+      coverageStatus: snapshot.buildCoverage?.status,
+      reason: snapshot.buildCoverage?.reason
+    }),
+    formatSnapshotGateLine({
+      gate: "lint",
+      status: snapshot.lintStatus,
+      coverageStatus: snapshot.lintCoverage?.status,
+      reason: snapshot.lintCoverage?.reason
+    }),
+    formatSnapshotGateLine({
+      gate: "test",
+      status: snapshot.testStatus,
+      coverageStatus: snapshot.testCoverage?.status,
+      reason: snapshot.testCoverage?.reason
+    }),
+    formatSnapshotGateLine({
+      gate: "format",
+      status: snapshot.formatPassed ? "passed" : snapshot.formatStatus === "verified" ? "failed" : "not_run",
+      coverageStatus: snapshot.formatCoverage?.status ?? snapshot.formatStatus,
+      reason: snapshot.formatCoverage?.reason
+    })
+  ];
+}
+
+export {
+  formatTaskReportReceipt,
+  FUSION_SYNTHESIS_MANIFEST_VERSION,
+  resolveFusionSynthesisTarget,
+  runFusionSynthesis,
+  buildJudgeCompletenessTelemetryFromVariants,
+  shouldStopBeforeJudgeOrSynthesis,
+  resolveHandoffPathFromStatePath,
+  buildPortableResultsCommand,
+  buildMatrixEvaluationCommand,
+  quoteReplayArg,
+  formatJudgeSkippedWarning,
+  formatJudgeNoWinnerWarning,
+  formatSynthesisOutcomeSummary,
+  formatCompetitionApplyNextSteps,
+  formatSynthesisFailureNextSteps,
+  buildCompeteRunMetadata,
+  resolvePersistedJudgeRunState,
+  resolveWinnerVerifiedForDecision,
+  formatMatrixProfileWinners,
+  formatMatrixProfileDecision,
+  resolveMatrixDefaultWinnerSource,
+  mergeJudgeEvaluatedVariantSignals,
+  attachMatrixAdvisoryToSynthesisContext,
+  isLowConfidenceBaselineReason,
+  resolveEffectiveJudgeDecision,
+  formatMatrixAutoRunReason,
+  resolveWinnerMethodForDisplay,
+  maybePromoteAlgorithmicFallbackWinner,
+  isJudgeUnavailableDecision,
+  isJudgeInconclusiveDecision,
+  resolveAlgorithmicFallbackWinner,
+  findVariantStateFile,
+  applyWinnerCompletionMode,
+  persistJudgeResults,
+  reconcileVariantResultsTelemetry,
+  logJudgeEvaluationTelemetry,
+  loadConfiguredConcurrency,
+  concurrencyAdvisoryMessage,
+  hasUsableAnalysisOutput,
+  executeCompetitionSynthesis,
+  hasNonEmptyEditEvidence,
+  countVariantFilesChanged,
+  formatVariantChangeSummary,
+  shouldFailForEmptyEditDelivery,
+  formatEmptyEditDeliveryWarning,
+  pickWorseSynthesisStatus,
+  formatCompetitionDeliveryResultLabel,
+  formatJudgeOffVariantStatus,
+  isJudgeOffMultiVariantWithoutWinner,
+  resolveFusionDeliveryExit,
+  computeCompetitionTerminalExit,
+  getRequiredGateAwareDisplayVerdict,
+  formatMatrixPrimaryDisagreementSummary,
+  resolveMatrixDisagreementPrimary,
+  resolveJudgeRequestedLabel,
+  renderRepairOutcomeRunSummary,
+  scoreForVariantFromTop2,
+  scoreForRunSummaryPrimary,
+  formatRunSummaryScoreCalibration,
+  describeAggregateBasis,
+  formatCompetitionRunSummaryCostLabel,
+  formatRunSummaryConfidence,
+  formatSlowPostProviderPhases,
+  hasJudgeSynthesisSignal,
+  formatWinnerJudgeSignal,
+  formatFinalCompetitionDecisionTraceLines,
+  formatSynthesisGateTraceLines,
+  parseProviderLimits,
+  resolveNativeResearchTraceDir,
+  persistNativeResearchTraces,
+  parseDeliverableContract,
+  computeDeliverableContract
+};
+//# sourceMappingURL=chunk-QP4UTSOV.js.map