@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-762ACDZJ.js

@@ -0,0 +1,4696 @@
+import {
+  buildWinnerReconciliationForResults,
+  formatAnalysisSynthesisArtifactPath,
+  formatInterruptedCompetitionNotice,
+  getDisplayVerificationVerdict,
+  getLatestWinnerFlipForTask,
+  hasUsableFusionRecommendation,
+  normalizeRequiredGatePolicy,
+  renderAnalysisSynthesisMarkdown,
+  renderFusionDeliverableMarkdown,
+  scoreForVariant,
+  variantHandlesMatchForResults
+} from "./chunk-LWGKN2GY.js";
+import {
+  reconcileRunNestedOptions
+} from "./chunk-QWDV4OSL.js";
+import {
+  resolveSynthesisDeliveryProjection,
+  undeliveredLineFromTelemetry,
+  undeliveredLineLookup
+} from "./chunk-NTD6CSI6.js";
+import {
+  deriveSynthesisValueFromArtifactOrSummary,
+  formatSynthesisValueRunSummaryLine
+} from "./chunk-I6FN3R5D.js";
+import {
+  readRunTaskState
+} from "./chunk-DFHX4XYA.js";
+import {
+  findLabRunStateForTask,
+  listLabRunDirs
+} from "./chunk-FT7SGLXT.js";
+import {
+  extractTitleFromPrompt,
+  formatExecutionModeLabel,
+  formatTaskLabel
+} from "./chunk-2L36U25O.js";
+import {
+  formatJudgeCoverageSummary,
+  isSemanticNoWinnerReason
+} from "./chunk-DCACX7BV.js";
+import {
+  getCompetitionOperationalReadbackV1,
+  toFusionOperationalReadbackV1
+} from "./chunk-HBTTGVR5.js";
+import {
+  getMostRecentCompetitionId,
+  getRunSnapshotV1,
+  normaliseInputSpecWarning,
+  readCompetitionState,
+  resolveCliStateRoots
+} from "./chunk-AAAODV76.js";
+import {
+  TaskIdSchema
+} from "./chunk-AISTV5XU.js";
+import {
+  TelemetryLogger,
+  judgeModelLabel
+} from "./chunk-PFCXFO7A.js";
+import {
+  repairDuplicatedProviderSegment
+} from "./chunk-GZK62I3N.js";
+import {
+  resolveProgressNarrationConfig
+} from "./chunk-C3DH3NCY.js";
+import {
+  validateCommandOptions
+} from "./chunk-I7SCBHJN.js";
+import {
+  normalizeForReconciliation
+} from "./chunk-TGXXYDL4.js";
+import {
+  parseJsonWithContext,
+  parseJsonWithFallback
+} from "./chunk-P6SSWAKY.js";
+import {
+  formatApplicationVerificationLine
+} from "./chunk-SKTFRFQ7.js";
+import {
+  readVariantVerification
+} from "./chunk-3OPP2OZB.js";
+import {
+  LabPathResolver
+} from "./chunk-C3KCMAJP.js";
+import {
+  readDirsForStateRoot,
+  resolveCheckoutRoot,
+  resolveLabsRoot
+} from "./chunk-AJN5Y5YZ.js";
+import {
+  getProviderConfig
+} from "./chunk-QJ6OEH4K.js";
+
+// src/cli/commands/compete-results.ts
+import fs from "fs";
+import path2 from "path";
+import chalk6 from "chalk";
+import { Command } from "commander";
+import { z } from "zod";
+
+// src/core/progress/judge-operations-projection.ts
+var JUDGE_OPERATIONS_PROJECTION_VERSION = "1.0.0";
+var NO_JUDGE_BY_DESIGN = "No judge by design";
+var NON_JUDGING_RUN_KINDS = /* @__PURE__ */ new Set(["fusion"]);
+var UNAVAILABLE_NOT_RECORDED = { state: "unavailable", reason: "not_recorded" };
+function evidence(value, reason = "not_recorded") {
+  return value === void 0 || value === null ? { state: "unavailable", reason } : { state: "available", value };
+}
+function stringEvidence(value, reason = "not_recorded") {
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  return trimmed.length > 0 ? { state: "available", value: trimmed } : { state: "unavailable", reason };
+}
+function stringList(values) {
+  if (!Array.isArray(values)) return [];
+  return values.filter((value) => typeof value === "string").map((value) => value.trim()).filter((value) => value.length > 0);
+}
+function unavailableEvidence(reason) {
+  return { state: "unavailable", reason };
+}
+function hasNoJudgeEvidence(facts) {
+  return facts.judge === void 0 && facts.matrix === void 0 && facts.decision === void 0 && facts.judgesExecuted === void 0 && facts.winner === void 0 && facts.confidence === void 0 && facts.criteria === void 0 && (facts.judgeFailures === void 0 || facts.judgeFailures.length === 0);
+}
+function recordDegraded(facts) {
+  return facts.health?.state === "degraded" || facts.health?.state === "unavailable";
+}
+function matrixState(matrix) {
+  if (matrix === void 0) return "unavailable";
+  if (matrix.autoRun === true) return "escalated";
+  if (matrix.autoRun === false) return "not_escalated";
+  return "unavailable";
+}
+function matrixProfileDecision(matrix) {
+  if (matrix === void 0) return "unknown";
+  if (matrix.profileDecision === "unanimous" || matrix.profileDecision === "split" || matrix.profileDecision === "inconclusive") {
+    return matrix.profileDecision;
+  }
+  if (matrix.winnerStatus === "inconclusive") return "inconclusive";
+  if (typeof matrix.profilesDisagree === "boolean") {
+    return matrix.profilesDisagree ? "split" : "unanimous";
+  }
+  return "unknown";
+}
+function judgePhase(facts, escalated) {
+  const status = facts.judge?.status;
+  if (status === "disabled" || status === "skipped") return "not_requested";
+  if (status === "requested") return escalated ? "escalated" : "judging";
+  if (status === "completed" || status === "failed") return "complete";
+  if (escalated) return "escalated";
+  return "unavailable";
+}
+function judgeStatus(facts, phase, winner) {
+  const status = facts.judge?.status;
+  if (status === "disabled" || status === "skipped") return "not_run";
+  if (status === "failed") return "degraded";
+  if (phase === "judging" || phase === "escalated") {
+    return status === "completed" ? judgedOutcome(facts, winner) : "in_flight";
+  }
+  if (status === "completed") return judgedOutcome(facts, winner);
+  return "unavailable";
+}
+function judgedOutcome(facts, winner) {
+  if ((facts.judgeFailures ?? []).length > 0) return "degraded";
+  if (winner.state === "no_winner") return "inconclusive";
+  if (winner.state === "unavailable") return "unavailable";
+  if (facts.matrix?.winnerStatus === "inconclusive") return "inconclusive";
+  return "decisive";
+}
+function winnerProjection(facts) {
+  if (facts.winner === null) return { state: "no_winner" };
+  const recorded = facts.winner;
+  const selectedVariant = facts.decision?.selectedVariant;
+  if (recorded === void 0) {
+    if (stringEvidence(selectedVariant).state === "unavailable") {
+      const status = facts.judge?.status;
+      if (status === "disabled" || status === "skipped") {
+        return { state: "unavailable", reason: "not_run" };
+      }
+      if (status === "requested") return { state: "unavailable", reason: "in_flight" };
+      return { state: "unavailable", reason: "not_recorded" };
+    }
+    return {
+      state: "selected",
+      identity: {
+        variant: stringEvidence(selectedVariant),
+        provider: UNAVAILABLE_NOT_RECORDED,
+        model: UNAVAILABLE_NOT_RECORDED,
+        strategy: UNAVAILABLE_NOT_RECORDED,
+        selectionSource: UNAVAILABLE_NOT_RECORDED,
+        selectionReason: UNAVAILABLE_NOT_RECORDED
+      }
+    };
+  }
+  return {
+    state: "selected",
+    identity: {
+      variant: stringEvidence(recorded.variant ?? selectedVariant),
+      provider: stringEvidence(recorded.provider),
+      // `resolvedModel` is the model the run actually used when recorded.
+      model: stringEvidence(recorded.resolvedModel ?? recorded.model),
+      strategy: stringEvidence(recorded.strategy),
+      selectionSource: stringEvidence(recorded.winnerSelectionSource),
+      selectionReason: stringEvidence(recorded.winnerSelectionReason)
+    }
+  };
+}
+function artifactProjection(facts) {
+  const synthesis = facts.synthesis;
+  const application = facts.application;
+  return {
+    synthesis: synthesis === void 0 ? unavailableEvidence("not_recorded") : {
+      state: "available",
+      value: {
+        status: stringEvidence(synthesis.status),
+        expected: evidence(synthesis.expected),
+        artifactPath: stringEvidence(synthesis.artifactPath),
+        jsonPath: stringEvidence(synthesis.jsonPath),
+        contributorCount: evidence(synthesis.contributorCount)
+      }
+    },
+    delivery: application === void 0 ? unavailableEvidence("not_recorded") : {
+      state: "available",
+      value: {
+        status: stringEvidence(application.status),
+        variantId: stringEvidence(application.variantId),
+        branch: stringEvidence(application.targetBranch),
+        commit: stringEvidence(application.targetPostApplyHeadSha)
+      }
+    }
+  };
+}
+function criteriaProjection(facts) {
+  const criteria = facts.criteria;
+  if (criteria === void 0) return unavailableEvidence("not_recorded");
+  const mapped = criteria.filter(
+    (entry) => typeof entry?.criterion === "string" && entry.criterion.trim().length > 0 && typeof entry.assessment === "string" && entry.assessment.trim().length > 0
+  ).map((entry) => ({
+    criterion: entry.criterion.trim(),
+    assessment: entry.assessment.trim(),
+    evidence: stringList(entry.evidence),
+    provenance: stringEvidence(entry.provenance)
+  }));
+  return mapped.length > 0 ? { state: "available", value: mapped } : unavailableEvidence("not_recorded");
+}
+function stackProjection(facts) {
+  const executed = stringList(facts.judgesExecuted);
+  const primaryJudge = stringEvidence(facts.decision?.primaryJudge);
+  const executedEvidence = facts.judgesExecuted === void 0 ? (
+    // A recorded primary judge is itself evidence that one judge executed.
+    primaryJudge.state === "available" ? { state: "available", value: [primaryJudge.value] } : unavailableEvidence("not_recorded")
+  ) : { state: "available", value: executed };
+  return {
+    requested: stringEvidence(facts.judge?.requested),
+    executed: executedEvidence,
+    failures: (facts.judgeFailures ?? []).map((failure) => ({
+      judgeType: typeof failure?.judgeType === "string" ? failure.judgeType.trim() : "",
+      reason: typeof failure?.reason === "string" ? failure.reason.trim() : ""
+    })).filter((failure) => failure.judgeType.length > 0 || failure.reason.length > 0)
+  };
+}
+function verdictProjection(facts) {
+  const confidence = facts.confidence;
+  return {
+    primaryJudge: stringEvidence(facts.decision?.primaryJudge),
+    outcome: stringEvidence(facts.decision?.decisionOutcome ?? facts.decision?.outcome),
+    reason: stringEvidence(facts.decision?.reason ?? facts.judge?.reason),
+    confidence: typeof confidence === "number" && Number.isFinite(confidence) ? { state: "available", value: confidence } : unavailableEvidence("not_recorded")
+  };
+}
+function matrixProjection(facts) {
+  const matrix = facts.matrix;
+  const state = matrixState(matrix);
+  return {
+    state,
+    evaluatorType: stringEvidence(matrix?.evaluatorType),
+    profiles: evidence(matrix?.profiles),
+    winnerStatus: stringEvidence(matrix?.winnerStatus),
+    escalationReasons: stringList(matrix?.escalationReasons),
+    profileDecision: matrixProfileDecision(matrix),
+    caveats: stringList(matrix?.winnerCaveats),
+    blockingHumanChecks: matrix?.blockingHumanChecks === void 0 ? unavailableEvidence("not_recorded") : { state: "available", value: stringList(matrix.blockingHumanChecks) },
+    advisoryHumanChecks: matrix?.advisoryHumanChecks === void 0 ? unavailableEvidence("not_recorded") : { state: "available", value: stringList(matrix.advisoryHumanChecks) }
+  };
+}
+function recordCaveats(facts) {
+  const health = facts.health;
+  if (health === void 0) return [];
+  const caveats = [];
+  if (health.state !== "healthy") caveats.push(`health ${health.state}`);
+  for (const issue of stringList(health.issues)) caveats.push(`issue ${issue}`);
+  return caveats;
+}
+function notApplicableProjection(facts) {
+  return {
+    version: JUDGE_OPERATIONS_PROJECTION_VERSION,
+    runId: facts.id,
+    kind: facts.kind,
+    applicability: "not_applicable",
+    notApplicableReason: NO_JUDGE_BY_DESIGN,
+    phase: "not_applicable",
+    status: "not_applicable",
+    stack: {
+      requested: unavailableEvidence("not_applicable"),
+      executed: unavailableEvidence("not_applicable"),
+      failures: []
+    },
+    verdict: {
+      primaryJudge: unavailableEvidence("not_applicable"),
+      outcome: unavailableEvidence("not_applicable"),
+      reason: unavailableEvidence("not_applicable"),
+      confidence: unavailableEvidence("not_applicable")
+    },
+    matrix: {
+      state: "unavailable",
+      evaluatorType: unavailableEvidence("not_applicable"),
+      profiles: unavailableEvidence("not_applicable"),
+      winnerStatus: unavailableEvidence("not_applicable"),
+      escalationReasons: [],
+      profileDecision: "unknown",
+      caveats: [],
+      blockingHumanChecks: unavailableEvidence("not_applicable"),
+      advisoryHumanChecks: unavailableEvidence("not_applicable")
+    },
+    criteria: unavailableEvidence("not_applicable"),
+    winner: { state: "unavailable", reason: "not_applicable" },
+    // Fusion still synthesizes and delivers, so artifact evidence is reported.
+    artifacts: artifactProjection(facts),
+    caveats: recordCaveats(facts)
+  };
+}
+function projectJudgeOperations(facts) {
+  if (NON_JUDGING_RUN_KINDS.has(facts.kind)) return notApplicableProjection(facts);
+  const winner = winnerProjection(facts);
+  const matrix = matrixProjection(facts);
+  const historical = hasNoJudgeEvidence(facts);
+  const phase = historical ? "unavailable" : judgePhase(facts, matrix.state === "escalated");
+  const status = historical ? "unavailable" : judgeStatus(facts, phase, winner);
+  return {
+    version: JUDGE_OPERATIONS_PROJECTION_VERSION,
+    runId: facts.id,
+    kind: facts.kind,
+    applicability: "applicable",
+    phase,
+    status: (
+      // A degraded canonical record cannot support a decisive claim.
+      status === "decisive" && recordDegraded(facts) ? "degraded" : status
+    ),
+    stack: stackProjection(facts),
+    verdict: verdictProjection(facts),
+    matrix,
+    criteria: criteriaProjection(facts),
+    winner,
+    artifacts: artifactProjection(facts),
+    caveats: recordCaveats(facts)
+  };
+}
+
+// src/core/progress/run-progress-projection.ts
+var RUN_PROGRESS_VARIANT_LIMIT = 20;
+var RUN_PROGRESS_MAX_LINE_CHARS = 160;
+var DEFAULT_OBSERVED_ACTIVITY_MAX_AGE_MS = 6e4;
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "succeeded",
+  "failed",
+  "cancelled"
+]);
+var OBSERVED_ACTIVITY_LABELS = {
+  tool: {
+    apply_patch: "applying edits",
+    bash: "running command",
+    build: "building",
+    edit: "editing files",
+    edit_file: "editing files",
+    glob: "inspecting files",
+    grep: "searching files",
+    lint: "linting",
+    read: "reading files",
+    read_file: "reading files",
+    search: "searching files",
+    shell: "running command",
+    test: "running tests",
+    verify: "verifying",
+    write: "writing files",
+    write_file: "writing files"
+  },
+  step: {
+    active: "working",
+    building: "building",
+    editing: "editing",
+    inspecting: "inspecting",
+    linting: "linting",
+    planning: "planning",
+    searching: "searching",
+    testing: "testing",
+    verifying: "verifying"
+  }
+};
+function observedActivityLabel(signal) {
+  const key = signal.name.trim().toLowerCase();
+  if (!/^[a-z][a-z0-9_-]*$/.test(key)) return void 0;
+  return OBSERVED_ACTIVITY_LABELS[signal.kind][key];
+}
+function truncateLine(text) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (normalized.length <= RUN_PROGRESS_MAX_LINE_CHARS) return normalized;
+  return `${normalized.slice(0, RUN_PROGRESS_MAX_LINE_CHARS - 3)}...`;
+}
+function boundedVariantLimit(value) {
+  if (value === void 0 || !Number.isFinite(value)) return RUN_PROGRESS_VARIANT_LIMIT;
+  return Math.min(RUN_PROGRESS_VARIANT_LIMIT, Math.max(0, Math.floor(value)));
+}
+function isStale(facts) {
+  return facts.freshness.state === "stale" || facts.health.issues.includes("stale");
+}
+function hasStartedWork(facts) {
+  if (facts.progress.completedVariants > 0) return true;
+  if (facts.variants.some((variant) => variant.status !== "running")) return true;
+  if (facts.variants.some((variant) => (variant.changedFiles ?? 0) > 0)) return true;
+  const { createdAt, lastActivityAt } = facts.timestamps;
+  if (!lastActivityAt) return false;
+  if (!createdAt) return true;
+  return Date.parse(lastActivityAt) > Date.parse(createdAt);
+}
+function deriveRunProgressPhase(facts) {
+  if (TERMINAL_STATUSES.has(facts.status)) return "completed";
+  if (isStale(facts)) return "stale";
+  if (facts.status === "unknown") return "unknown";
+  switch (facts.phase) {
+    case "judge":
+      return "judging";
+    case "synthesis":
+      return "synthesizing";
+    case "delivery":
+      return "finalizing";
+    case "execution":
+      return hasStartedWork(facts) ? "active" : "queued";
+    default:
+      return "unknown";
+  }
+}
+function variantPhase(variant) {
+  if (variant.status === "succeeded" || variant.status === "failed" || variant.status === "cancelled") {
+    return "completed";
+  }
+  if (variant.status === "unknown") return "unknown";
+  switch (variant.phase) {
+    case "judge":
+      return "judging";
+    case "synthesis":
+      return "synthesizing";
+    case "delivery":
+      return "finalizing";
+    case "execution":
+      return (variant.changedFiles ?? 0) > 0 ? "active" : "queued";
+    default:
+      return "unknown";
+  }
+}
+function coarseVariantDetail(variant, phase) {
+  switch (phase) {
+    case "completed": {
+      const gates = [
+        variant.verification?.buildStatus ? `build ${variant.verification.buildStatus}` : void 0,
+        variant.verification?.testStatus ? `tests ${variant.verification.testStatus}` : void 0
+      ].filter((value) => value !== void 0);
+      const outcome = variant.status === "succeeded" ? "succeeded" : variant.status;
+      return gates.length > 0 ? `${outcome}, ${gates.join(", ")}` : outcome;
+    }
+    case "queued":
+      return variant.status === "detached" ? "detached, no local activity observed" : "queued";
+    case "active": {
+      const changed = variant.changedFiles ?? 0;
+      return changed > 0 ? `working, ${changed} file(s) changed` : "working";
+    }
+    case "verifying":
+      return "verifying";
+    case "finalizing":
+      return "finalizing";
+    case "judging":
+      return "judging";
+    case "synthesizing":
+      return "synthesizing";
+    case "stale":
+      return "no recent activity observed";
+    default:
+      return "state unavailable";
+  }
+}
+function resolveObservedDetail(runId, variant, phase, options, now) {
+  const coarse = { text: coarseVariantDetail(variant, phase), observed: false };
+  const signal = options.observedActivity?.[runId]?.[variant.id];
+  if (signal === void 0) return coarse;
+  if (phase !== "active" && phase !== "verifying") return coarse;
+  const maxAgeMs = options.observedActivityMaxAgeMs ?? DEFAULT_OBSERVED_ACTIVITY_MAX_AGE_MS;
+  const age = now - signal.observedAt;
+  if (!Number.isFinite(age) || age < 0 || age > maxAgeMs) return coarse;
+  const label = observedActivityLabel(signal);
+  if (label === void 0) return coarse;
+  return {
+    text: label,
+    observed: true
+  };
+}
+function variantLine(runId, variant, options, now) {
+  const phase = variantPhase(variant);
+  const detail = resolveObservedDetail(runId, variant, phase, options, now);
+  const label = variant.model ? `${variant.provider} ${variant.model}` : variant.provider;
+  return {
+    variantId: variant.id,
+    provider: variant.provider,
+    status: variant.status,
+    phase,
+    observed: detail.observed,
+    detail: truncateLine(`${phase}: ${detail.text}`),
+    text: truncateLine(`${label} ${phase}: ${detail.text}`)
+  };
+}
+function snapshotCaveats(facts) {
+  const caveats = [];
+  if (facts.health.state !== "healthy") caveats.push(`health ${facts.health.state}`);
+  for (const issue of facts.health.issues) caveats.push(`issue ${issue}`);
+  if (facts.freshness.state === "stale" || facts.freshness.state === "unknown") {
+    caveats.push(`freshness ${facts.freshness.state}`);
+  }
+  return caveats;
+}
+function aggregateDetail(facts, phase, caveats) {
+  const { completedVariants, totalVariants } = facts.progress;
+  const counts = totalVariants > 0 ? `${completedVariants}/${totalVariants} variants complete` : "";
+  const parts = [];
+  if (phase === "completed") parts.push(facts.status);
+  if (phase === "stale") parts.push("no recent activity observed");
+  if (phase === "unknown") parts.push("run state unavailable");
+  if (counts) parts.push(counts);
+  if (caveats.length > 0) parts.push(caveats.join(", "));
+  return parts.join(" | ");
+}
+function activityStatus(status) {
+  if (status === "running") return "running";
+  if (status === "succeeded") return "succeeded";
+  if (status === "failed") return "failed";
+  if (status === "cancelled") return "cancelled";
+  return "unknown";
+}
+function activityLabel(phase) {
+  if (phase === "judging") return "Judge";
+  if (phase === "synthesizing") return "Synthesis";
+  if (phase === "finalizing") return "Delivery";
+  if (phase === "completed") return "Outcome";
+  return "Execution";
+}
+function projectActivity(facts, phase, text, variants) {
+  const terminal = TERMINAL_STATUSES.has(facts.status);
+  const status = terminal ? facts.status === "succeeded" ? "succeeded" : facts.status === "failed" ? "failed" : facts.status === "cancelled" ? "cancelled" : "unknown" : phase === "stale" || phase === "unknown" ? "unknown" : "running";
+  return {
+    schemaVersion: "1.0.0",
+    position: facts.progress.totalVariants > 0 ? `${facts.progress.completedVariants} of ${facts.progress.totalVariants} variants complete` : null,
+    milestones: [
+      {
+        id: phase,
+        label: activityLabel(phase),
+        status,
+        detail: text,
+        items: variants.map((variant) => ({
+          id: variant.variantId,
+          label: variant.provider,
+          status: activityStatus(variant.status),
+          detail: variant.detail
+        }))
+      }
+    ]
+  };
+}
+function progressSignature(facts, phase, variants, caveats) {
+  const variantPart = variants.map((variant) => `${variant.variantId}=${variant.phase}:${variant.text}`).join(";");
+  return [
+    facts.id,
+    facts.status,
+    phase,
+    `${facts.progress.completedVariants}/${facts.progress.totalVariants}`,
+    caveats.join(","),
+    variantPart
+  ].join("|");
+}
+function snapshotTimestamp(facts) {
+  const timestamps = [
+    facts.timestamps.createdAt,
+    facts.timestamps.updatedAt,
+    facts.timestamps.completedAt,
+    facts.timestamps.lastActivityAt
+  ].map((value) => value === void 0 ? void 0 : Date.parse(value)).filter((value) => value !== void 0 && Number.isFinite(value));
+  const latest = timestamps.length > 0 ? Math.max(...timestamps) : 0;
+  return new Date(latest).toISOString();
+}
+function projectRunProgress(facts, options = {}) {
+  const now = options.now !== void 0 && Number.isFinite(options.now) ? options.now : Date.now();
+  const phase = deriveRunProgressPhase(facts);
+  const caveats = snapshotCaveats(facts);
+  const limit = boundedVariantLimit(options.variantLimit);
+  const variants = limit === 0 ? [] : [...facts.variants].sort((left, right) => left.id.localeCompare(right.id)).slice(0, limit).map((variant) => variantLine(facts.id, variant, options, now));
+  const detail = aggregateDetail(facts, phase, caveats);
+  const text = truncateLine(
+    detail ? `${facts.kind} ${phase}: ${detail}` : `${facts.kind} ${phase}`
+  );
+  return {
+    runId: facts.id,
+    phase,
+    text,
+    progress: { ...facts.progress },
+    terminal: TERMINAL_STATUSES.has(facts.status),
+    caveats,
+    variants,
+    activityV1: projectActivity(facts, phase, text, variants),
+    signature: progressSignature(facts, phase, variants, caveats),
+    snapshotAt: snapshotTimestamp(facts),
+    observedAt: new Date(now).toISOString()
+  };
+}
+
+// src/core/progress/run-narration-request.ts
+var RUN_NARRATION_REQUEST_VERSION = "1.0.0";
+var RUN_NARRATION_DEFAULT_MIN_INTERVAL_MS = 15e3;
+var RUN_NARRATION_DEFAULT_MAX_AGE_MS = 6e4;
+var RUN_NARRATION_DEFAULT_TIMEOUT_MS = 1e4;
+var RUN_NARRATION_DEFAULT_MAX_FAILURES = 3;
+function nonEmpty(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function boundedInteger(value, fallback, maximum) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  const integer = Math.floor(value);
+  if (integer <= 0) return fallback;
+  return Math.min(integer, maximum);
+}
+function normalizeProgressNarrationConfig(input) {
+  const provider = nonEmpty(input?.provider);
+  const model = nonEmpty(input?.model);
+  const enabled = input?.enabled === true && provider !== void 0;
+  return {
+    enabled,
+    ...enabled ? { provider } : {},
+    ...enabled && model ? { model } : {},
+    minIntervalMs: boundedInteger(
+      input?.minIntervalMs,
+      RUN_NARRATION_DEFAULT_MIN_INTERVAL_MS,
+      6e5
+    ),
+    maxAgeMs: boundedInteger(input?.maxAgeMs, RUN_NARRATION_DEFAULT_MAX_AGE_MS, 6e5),
+    maxChars: boundedInteger(
+      input?.maxChars,
+      RUN_PROGRESS_MAX_LINE_CHARS,
+      RUN_PROGRESS_MAX_LINE_CHARS
+    ),
+    timeoutMs: boundedInteger(input?.timeoutMs, RUN_NARRATION_DEFAULT_TIMEOUT_MS, 12e4),
+    maxConsecutiveFailures: boundedInteger(
+      input?.maxConsecutiveFailures,
+      RUN_NARRATION_DEFAULT_MAX_FAILURES,
+      20
+    )
+  };
+}
+function boundedFactText(value, maximum) {
+  const withoutControlCharacters = [...value].map((character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    return codePoint <= 31 || codePoint === 127 ? " " : character;
+  }).join("");
+  const normalized = withoutControlCharacters.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maximum) return normalized;
+  return `${normalized.slice(0, Math.max(1, maximum - 3))}...`;
+}
+function buildRunNarrationRequestV1(projection, configInput, advisoryInput) {
+  const config = normalizeProgressNarrationConfig(configInput);
+  return {
+    schemaVersion: RUN_NARRATION_REQUEST_VERSION,
+    enabled: config.enabled,
+    provider: config.provider ?? null,
+    model: config.model ?? null,
+    minIntervalMs: config.minIntervalMs,
+    maxAgeMs: config.maxAgeMs,
+    maxChars: config.maxChars,
+    timeoutMs: config.timeoutMs,
+    maxConsecutiveFailures: config.maxConsecutiveFailures,
+    signature: projection.signature,
+    advisory: {
+      configurationError: advisoryInput?.configurationError ? boundedFactText(advisoryInput.configurationError, 200) : null
+    },
+    facts: {
+      runId: boundedFactText(projection.runId, 160),
+      phase: projection.phase,
+      terminal: projection.terminal,
+      progress: { ...projection.progress },
+      caveats: projection.caveats.slice(0, 10).map((value) => boundedFactText(value, 80)),
+      variants: projection.variants.slice(0, RUN_PROGRESS_VARIANT_LIMIT).map((variant) => ({
+        variantId: boundedFactText(variant.variantId, 160),
+        provider: boundedFactText(variant.provider, 80),
+        phase: variant.phase,
+        detail: boundedFactText(variant.text, RUN_PROGRESS_MAX_LINE_CHARS)
+      }))
+    }
+  };
+}
+
+// src/cli/formatters/warning-formatter.ts
+import chalk from "chalk";
+var WarningFormatter = class {
+  verbosity;
+  /**
+   * Create a new warning formatter.
+   *
+   * @param verbosity - Output verbosity level (defaults to 'normal')
+   */
+  constructor(verbosity = "normal") {
+    this.verbosity = verbosity;
+  }
+  /**
+   * Format warnings for CLI display.
+   *
+   * Groups warnings by severity and formats according to verbosity level.
+   *
+   * @param warnings - Array of structured warnings to format
+   * @returns Formatted warning output string
+   */
+  formatWarnings(warnings) {
+    if (this.verbosity === "silent" || warnings.length === 0) {
+      return "";
+    }
+    const lines = [];
+    const errors = warnings.filter((w) => w.severity === "ERROR");
+    const warns = warnings.filter((w) => w.severity === "WARN");
+    const infos = warnings.filter((w) => w.severity === "INFO");
+    if (this.verbosity === "minimal") {
+      const parts = [];
+      if (errors.length > 0) {
+        parts.push(chalk.red(`${errors.length} error(s)`));
+      }
+      if (warns.length > 0) {
+        parts.push(chalk.yellow(`${warns.length} warning(s)`));
+      }
+      return parts.join(", ");
+    }
+    if (errors.length > 0) {
+      lines.push(chalk.red.bold("\nErrors:"));
+      for (const warning of errors) {
+        lines.push(this.formatWarning(warning));
+      }
+    }
+    if (warns.length > 0) {
+      lines.push(chalk.yellow.bold("\nWarnings:"));
+      for (const warning of warns) {
+        lines.push(this.formatWarning(warning));
+      }
+    }
+    if (this.verbosity === "verbose" && infos.length > 0) {
+      lines.push(chalk.blue.bold("\nInfo:"));
+      for (const warning of infos) {
+        lines.push(this.formatWarning(warning));
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Format a single warning.
+   *
+   * @param warning - The warning to format
+   * @returns Formatted warning string
+   */
+  formatWarning(warning) {
+    const lines = [];
+    const label = this.getLabelForSeverity(warning.severity);
+    const color = this.getColorForSeverity(warning.severity);
+    lines.push(color(`  ${label} [${warning.code}] ${warning.message}`));
+    if (this.verbosity === "verbose") {
+      if (warning.context.provider) {
+        lines.push(chalk.dim(`      Provider: ${warning.context.provider}`));
+      }
+      if (warning.context.executionPhase) {
+        lines.push(chalk.dim(`      Phase: ${warning.context.executionPhase}`));
+      }
+      if (warning.recovered) {
+        lines.push(chalk.green(`      OK Recovered: ${warning.recoveryMechanism || "automatic"}`));
+      }
+      if (warning.metadata && Object.keys(warning.metadata).length > 0) {
+        lines.push(chalk.dim(`      Metadata: ${JSON.stringify(warning.metadata)}`));
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Format warning summary.
+   *
+   * Provides a concise summary of warnings by severity.
+   *
+   * @param warnings - Array of warnings to summarize
+   * @returns Formatted summary string
+   */
+  formatSummary(warnings) {
+    if (this.verbosity === "silent" || warnings.length === 0) {
+      return "";
+    }
+    const errors = warnings.filter((w) => w.severity === "ERROR").length;
+    const warns = warnings.filter((w) => w.severity === "WARN").length;
+    const infos = warnings.filter((w) => w.severity === "INFO").length;
+    const recovered = warnings.filter((w) => w.recovered).length;
+    const parts = [];
+    if (errors > 0) parts.push(chalk.red(`${errors} error(s)`));
+    if (warns > 0) parts.push(chalk.yellow(`${warns} warning(s)`));
+    if (infos > 0) parts.push(chalk.blue(`${infos} info`));
+    if (recovered > 0) parts.push(chalk.green(`${recovered} recovered`));
+    return parts.join(", ");
+  }
+  /**
+   * Format a validation result for CLI display.
+   *
+   * Intended for human-readable summaries of structured validation output.
+   */
+  formatValidationResult(result) {
+    if (this.verbosity === "silent") return "";
+    const statusLine = result.valid ? "Validation passed" : "Validation failed";
+    if (this.verbosity === "minimal") {
+      return statusLine;
+    }
+    const meta = result.metadata ?? {};
+    const icon = (ok) => ok ? "OK" : "Error";
+    const testsIcon = meta.testsRun === false ? "Error" : icon(meta.testsPass);
+    const lines = [statusLine];
+    lines.push(`Tests: ${testsIcon}`);
+    lines.push(`Lint: ${icon(meta.lintPass)}`);
+    lines.push(`Build: ${icon(meta.buildSuccess)}`);
+    lines.push(`Completeness: ${Math.round(meta.completeness ?? 0)}%`);
+    if (this.verbosity === "verbose") {
+      lines.push(`Git clean: ${icon(meta.gitClean)}`);
+      lines.push(`Warnings: ${result.warnings?.length ?? 0}`);
+      lines.push(`Errors: ${result.errors?.length ?? 0}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Update verbosity level.
+   *
+   * @param verbosity - New verbosity level
+   */
+  setVerbosity(verbosity) {
+    this.verbosity = verbosity;
+  }
+  /**
+   * Get current verbosity level.
+   *
+   * @returns Current verbosity level
+   */
+  getVerbosity() {
+    return this.verbosity;
+  }
+  /**
+   * Get plain label for warning severity.
+   *
+   * @param severity - Warning severity level
+   * @returns Label text
+   */
+  getLabelForSeverity(severity) {
+    switch (severity) {
+      case "ERROR":
+        return "Error:";
+      case "WARN":
+        return "Warning:";
+      case "INFO":
+        return "Info:";
+      default:
+        return "Info:";
+    }
+  }
+  /**
+   * Get chalk color function for warning severity.
+   *
+   * @param severity - Warning severity level
+   * @returns Chalk color function
+   */
+  getColorForSeverity(severity) {
+    switch (severity) {
+      case "ERROR":
+        return chalk.red;
+      case "WARN":
+        return chalk.yellow;
+      case "INFO":
+        return chalk.blue;
+      default:
+        return chalk.white;
+    }
+  }
+};
+
+// src/cli/handlers/compete/competition-status-projection.ts
+var SYNTHESIS_FAILURE_STATUSES = /* @__PURE__ */ new Set([
+  "failed",
+  "gate_failed",
+  "generation_failed",
+  "timed_out",
+  "editable_workspace_unavailable"
+]);
+var SYNTHESIS_DEGRADED_STATUSES = /* @__PURE__ */ new Set([...SYNTHESIS_FAILURE_STATUSES, "degraded", "partial"]);
+function resolveExecutionHealthFromCompetitionState(state) {
+  if (state.status === "running") {
+    const variants = [
+      ...state.variants ?? [],
+      ...getRawCompetitionCandidatesFromCompetitionState(state)
+    ];
+    return variants.some((variant) => variant.success === false) ? "degraded" : "clean";
+  }
+  const synthesis = resolveProjectionSynthesis(state);
+  if (synthesis?.expected === true && (isSynthesisDegradedStatus(synthesis.status) || state.runMetadata?.runSemantics === "fusion" && !synthesis.status)) {
+    if (state.runMetadata?.runSemantics === "fusion" && (isSynthesisFailureStatus(synthesis.status) || !synthesis.status)) {
+      return "failed";
+    }
+    return "degraded";
+  }
+  if (state.runMetadata?.runSemantics === "fusion" && synthesis?.expected === true && synthesis.status === "succeeded") {
+    return "clean";
+  }
+  if (isJudgeOffComparisonState(state)) {
+    return state.variants?.some((variant) => variant.success === false) ? "degraded" : "clean";
+  }
+  if (state.outcome !== "winner_selected" || !state.winner) {
+    return "failed";
+  }
+  return hasIncompleteWinnerSelectedVariant(state) ? "degraded" : "clean";
+}
+function resolveCompetitionResultFromCompetitionState(state) {
+  if (state.status === "running") return "incomplete";
+  const synthesis = resolveProjectionSynthesis(state);
+  if (synthesis?.expected === true) {
+    if (state.runMetadata?.runSemantics === "fusion" && (isSynthesisFailureStatus(synthesis.status) || !synthesis.status)) {
+      return "failed";
+    }
+    if (state.runMetadata?.runSemantics === "fusion" && synthesis.status === "succeeded") {
+      return "success";
+    }
+    if (isSynthesisDegradedStatus(synthesis.status)) {
+      return "degraded";
+    }
+  }
+  if (state.outcome === "winner_selected") {
+    return hasIncompleteWinnerSelectedVariant(state) ? "degraded" : "success";
+  }
+  if (isJudgeOffComparisonState(state)) return "incomplete";
+  return "failed";
+}
+function resolveCompetitionStatusFromCompetitionState(state) {
+  return {
+    competitionResult: resolveCompetitionResultFromCompetitionState(state),
+    executionHealth: resolveExecutionHealthFromCompetitionState(state)
+  };
+}
+function competitionStatusStateFromBasicResult(result) {
+  const variants = result.variants ?? [];
+  const synthesisStatus = resolveLiveSynthesisProjectionStatus(result.synthesisResult);
+  return {
+    outcome: result.winner ? "winner_selected" : "no_winner",
+    winner: result.winner ? result.winner : null,
+    winnerVerification: result.winnerVerification ?? null,
+    variants,
+    rawHandle: {
+      variants
+    },
+    runMetadata: {
+      runSemantics: "competition",
+      ...synthesisStatus ? {
+        synthesis: {
+          expected: true,
+          status: synthesisStatus
+        }
+      } : {}
+    }
+  };
+}
+function resolveProjectionSynthesis(state) {
+  const metadata = state.runMetadata?.synthesis;
+  const durableStatus = resolveLiveSynthesisProjectionStatus(getDurableSynthesisResult(state));
+  return {
+    expected: metadata?.expected === true || durableStatus !== void 0 ? true : metadata?.expected,
+    status: durableStatus ?? metadata?.status
+  };
+}
+function getDurableSynthesisResult(state) {
+  if (state.synthesis && typeof state.synthesis === "object") {
+    return state.synthesis;
+  }
+  const rawHandle = state.rawHandle && typeof state.rawHandle === "object" ? state.rawHandle : null;
+  const fromRaw = rawHandle?.synthesis;
+  if (fromRaw && typeof fromRaw === "object" && !Array.isArray(fromRaw)) {
+    return fromRaw;
+  }
+  return void 0;
+}
+function resolveLiveSynthesisProjectionStatus(synthesisResult) {
+  if (!synthesisResult) return void 0;
+  if (synthesisResult.synthesisApplied === true) return "succeeded";
+  if (synthesisResult.success === false || synthesisResult.synthesisOutcomeStatus === "gate_failed" || synthesisResult.synthesisOutcomeStatus === "generation_failed" || synthesisResult.synthesisOutcomeStatus === "timed_out" || synthesisResult.synthesisOutcomeStatus === "editable_workspace_unavailable") {
+    return "failed";
+  }
+  if (synthesisResult.winnerFallback === true || synthesisResult.synthesisOutcomeStatus === "winner_carry_forward" || synthesisResult.synthesisOutcomeStatus === "no_pick") {
+    return "no_pick";
+  }
+  return synthesisResult.success === true ? "succeeded" : void 0;
+}
+function isJudgeOffComparisonState(state) {
+  return state.outcome === "no_winner" && state.winner == null && (state.runMetadata?.judge?.status === "disabled" || state.runMetadata?.judge?.requested === "off" || state.decision?.reason === "judge_off");
+}
+function isSynthesisFailureStatus(status) {
+  return typeof status === "string" && SYNTHESIS_FAILURE_STATUSES.has(status);
+}
+function isSynthesisDegradedStatus(status) {
+  return typeof status === "string" && SYNTHESIS_DEGRADED_STATUSES.has(status);
+}
+function hasIncompleteWinnerSelectedVariant(state) {
+  if (hasUnverifiedWinnerEvidence(state)) {
+    return true;
+  }
+  const candidates = getRawCompetitionCandidatesFromCompetitionState(
+    state
+  );
+  if (candidates.some(
+    (variant) => Object.hasOwn(variant, "success") ? variant.success !== true : hasTerminalIncompleteSignal(variant)
+  )) {
+    return true;
+  }
+  const winner = state.winner;
+  return winner != null && Object.hasOwn(winner, "success") && winner.success !== true;
+}
+function hasUnverifiedWinnerEvidence(state) {
+  const original = state.winnerVerification?.original;
+  const originalStatus = normalizeStatusToken(original?.status);
+  if (original?.failed === true || originalStatus === "failed") return true;
+  if (originalStatus === "passed" || originalStatus === "baseline-clean") return false;
+  if (originalStatus === "not-run" || originalStatus === "no-data") {
+    return !isAnalysisIntentState(state);
+  }
+  const winnerCandidate = findWinnerCandidate(state);
+  if (!winnerCandidate || !hasExplicitVerificationEvidence(winnerCandidate)) {
+    return false;
+  }
+  return getDisplayVerificationVerdict({ ...winnerCandidate }, {
+    requiredGatePolicy: "build-only"
+  }).failed;
+}
+function findWinnerCandidate(state) {
+  const candidates = getRawCompetitionCandidatesFromCompetitionState(state);
+  if (candidates.length === 0) return null;
+  const winner = state.winner;
+  if (!winner) return candidates.length === 1 ? candidates[0] ?? null : null;
+  const byVariant = findUniqueCandidateByAlias(candidates, normalizeVariantToken(winner.variant), [
+    (candidate) => normalizeVariantToken(candidate.variant)
+  ]);
+  if (byVariant) return byVariant;
+  const byReconciledVariant = findUniqueCandidateByAlias(
+    candidates,
+    winner.variant ? normalizeForReconciliation(winner.variant) : null,
+    [
+      (candidate) => typeof candidate.variant === "string" ? normalizeForReconciliation(candidate.variant) : null
+    ]
+  );
+  if (byReconciledVariant) return byReconciledVariant;
+  const byProviderModelStrategy = findUniqueCandidateByAlias(
+    candidates,
+    buildVariantToken(winner.provider, winner.model ?? winner.resolvedModel, winner.strategy),
+    [
+      (candidate) => buildVariantToken(candidate.provider, candidate.model, candidate.strategy),
+      (candidate) => buildVariantToken(candidate.provider, candidate.resolvedModel, candidate.strategy)
+    ]
+  );
+  if (byProviderModelStrategy) return byProviderModelStrategy;
+  const byProviderStrategy = findUniqueCandidateByAlias(
+    candidates,
+    buildVariantToken(winner.provider, winner.strategy),
+    [(candidate) => buildVariantToken(candidate.provider, candidate.strategy)]
+  );
+  return byProviderStrategy ?? (candidates.length === 1 ? candidates[0] ?? null : null);
+}
+function findUniqueCandidateByAlias(candidates, winnerAlias, candidateAliases) {
+  if (!winnerAlias) return null;
+  const matches = candidates.filter(
+    (candidate) => candidateAliases.some((alias) => alias(candidate) === winnerAlias)
+  );
+  return matches.length === 1 ? matches[0] ?? null : null;
+}
+function hasExplicitVerificationEvidence(candidate) {
+  const outcome = candidate.outcome && typeof candidate.outcome === "object" && !Array.isArray(candidate.outcome) ? candidate.outcome : null;
+  const verification = outcome?.verification && typeof outcome.verification === "object" && !Array.isArray(outcome.verification) ? outcome.verification : null;
+  return [
+    verification?.status,
+    verification?.outcome,
+    verification?.buildStatus,
+    verification?.testStatus,
+    verification?.deterministicGatesPassed,
+    candidate.buildStatus,
+    candidate.testStatus
+  ].some((value) => value !== void 0 && value !== null);
+}
+function isAnalysisIntentState(state) {
+  if (normalizeStatusToken(state.runMetadata?.replay?.executionIntent) === "analysis") {
+    return true;
+  }
+  const winnerCandidate = findWinnerCandidate(state);
+  if (!winnerCandidate) return false;
+  if (normalizeStatusToken(winnerCandidate.executionIntent) === "analysis") return true;
+  const testsExecuted = winnerCandidate.testsExecuted && typeof winnerCandidate.testsExecuted === "object" && !Array.isArray(winnerCandidate.testsExecuted) ? winnerCandidate.testsExecuted : null;
+  return normalizeStatusToken(testsExecuted?.skipReason) === "analysis-intent";
+}
+function normalizeStatusToken(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim().replace(/_/g, "-") : null;
+}
+function normalizeVariantToken(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function buildVariantToken(...parts) {
+  if (!normalizeVariantToken(parts[0])) return null;
+  const tokens = parts.map(normalizeVariantToken).filter((token) => Boolean(token));
+  return tokens.join(":");
+}
+function getRawCompetitionCandidatesFromCompetitionState(state) {
+  const rawHandle = state.rawHandle && typeof state.rawHandle === "object" ? state.rawHandle : null;
+  return Array.isArray(rawHandle?.candidates) ? rawHandle.candidates : Array.isArray(rawHandle?.variants) ? rawHandle.variants : [];
+}
+function hasTerminalIncompleteSignal(variant) {
+  if (variant.timedOut === true) return true;
+  if (typeof variant.errorMessage === "string" && variant.errorMessage.trim().length > 0) {
+    return true;
+  }
+  if (typeof variant.terminationReason === "string" && variant.terminationReason.trim().length > 0) {
+    return true;
+  }
+  const verification = variant.outcome?.verification;
+  if (verification?.status === "failed" || verification?.buildStatus === "failed" || verification?.testStatus === "failed") {
+    return true;
+  }
+  if (typeof variant.completeness === "number" && Number.isFinite(variant.completeness)) {
+    return variant.completeness <= 0;
+  }
+  return false;
+}
+
+// src/cli/utils/default-competition-id.ts
+import path from "path";
+import chalk2 from "chalk";
+async function resolveDefaultCompetitionId(buildDir) {
+  const stateDir = LabPathResolver.getInstance().getStateDir(buildDir);
+  return getMostRecentCompetitionId({
+    stateDirs: readDirsForStateRoot(buildDir, stateDir).map(
+      (dir) => path.join(dir, "competitions")
+    ),
+    checkoutRoot: resolveCheckoutRoot(buildDir)
+  });
+}
+async function resolveDefaultCompetitionIdOrReport(buildDir) {
+  const recent = await resolveDefaultCompetitionId(buildDir);
+  if (!recent) {
+    console.error(
+      chalk2.red(
+        "\nError: No competition state found. Run a competition first, or pass a task ID.\n"
+      )
+    );
+    process.exitCode = 1;
+    return null;
+  }
+  console.error(chalk2.gray(`Using most recent competition: ${recent}`));
+  return recent;
+}
+
+// src/cli/utils/judge-operations-read.ts
+function recordedWinner(state) {
+  if (state.winner === null || state.outcome === "no_winner") return null;
+  return state.winner;
+}
+function judgeOperationsFactsForState(run, state) {
+  return {
+    id: run.id,
+    kind: run.kind,
+    judge: state.runMetadata?.judge,
+    matrix: state.runMetadata?.matrix,
+    synthesis: state.runMetadata?.synthesis,
+    decision: state.decision,
+    judgeFailures: state.judgeFailures,
+    winner: recordedWinner(state),
+    application: state.application,
+    health: run.health
+  };
+}
+function projectJudgeOperationsFromState(run, state) {
+  return projectJudgeOperations(judgeOperationsFactsForState(run, state));
+}
+
+// src/cli/utils/multi-judge-display.ts
+import chalk3 from "chalk";
+function logJsonParseFallback(context) {
+  return {
+    onError: (error) => console.warn(`Failed to parse ${context}: ${error}`)
+  };
+}
+function printLine(message) {
+  console.log(message);
+}
+function hasWinnerInResults(row) {
+  return Object.values(parseResultsJson(row)).some(
+    (entry) => typeof entry?.winner === "string" && entry.winner.trim().length > 0
+  );
+}
+function hasPrimaryWinner(row) {
+  const winner = row.primary_winner ?? row.primaryWinner;
+  return typeof winner === "string" && winner.trim().length > 0;
+}
+function primaryDeclaredNoWinner(row) {
+  if (hasPrimaryWinner(row)) return false;
+  const primary = row.primary_judge ?? row.primaryJudge;
+  if (!primary) return false;
+  const reason = parseResultsJson(row)[primary]?.noWinnerReason;
+  return isSemanticNoWinnerReason(reason);
+}
+function normalizeMultiJudgeRunRow(row) {
+  if (!row.no_winner_reason) return row;
+  if (!hasPrimaryWinner(row) && !hasWinnerInResults(row)) return row;
+  if (primaryDeclaredNoWinner(row)) return row;
+  return { ...row, no_winner_reason: null };
+}
+function parseJudgesExecuted(row) {
+  if (Array.isArray(row.judgesExecuted)) return row.judgesExecuted;
+  const raw = row.judges_executed ?? row.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);
+}
+function parseResultsJson(row) {
+  if (row.resultsJson && typeof row.resultsJson === "object" && !Array.isArray(row.resultsJson)) {
+    return row.resultsJson;
+  }
+  const raw = row.results_json ?? row.resultsJson;
+  if (typeof raw !== "string") return {};
+  const parsed = parseJsonWithFallback(
+    raw,
+    "multi_judge_runs.results_json",
+    {},
+    logJsonParseFallback("multi_judge_runs.results_json")
+  );
+  if (parsed.truncated === true && parsed.summary && typeof parsed.summary === "object" && !Array.isArray(parsed.summary)) {
+    return parsed.summary;
+  }
+  return parsed;
+}
+function secondaryJudgePicks(row) {
+  if (!primaryDeclaredNoWinner(row)) return [];
+  const primary = row.primary_judge ?? row.primaryJudge ?? null;
+  return Object.entries(parseResultsJson(row)).filter(([judge]) => judge !== primary).flatMap(
+    ([judge, entry]) => typeof entry?.winner === "string" && entry.winner.trim().length > 0 ? [{ judge, winner: entry.winner.trim() }] : []
+  );
+}
+function normalizeReasonLabel(value) {
+  return value.replace(/_/g, "-").replace(/\s+/g, " ").trim();
+}
+function readString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function readJudgeAudit(entry) {
+  return entry.metadata?.audit ?? {};
+}
+function getJudgeInvalidCause(entry) {
+  const audit = readJudgeAudit(entry);
+  const rationale = readString(entry.rationale);
+  const rationaleCause = rationale?.match(/\bcause:\s*([a-z_]+)/i)?.[1] ?? null;
+  return readString(entry.judgeInvalidCause) ?? readString(audit.judgeInvalidCause) ?? readString(audit.judgeInvalidReason) ?? readString(entry.judgeInvalidReason) ?? readString(rationaleCause) ?? null;
+}
+function classifyJudgeDisplayStatus(entry) {
+  if (entry.status === "skipped") {
+    return { kind: "skipped", reason: readString(entry.skippedReason) ?? "unspecified" };
+  }
+  if (typeof entry.winner === "string" && entry.winner.trim().length > 0) {
+    return { kind: "winner", winner: entry.winner.trim() };
+  }
+  const audit = readJudgeAudit(entry);
+  const invalidCause = getJudgeInvalidCause(entry);
+  const rationale = readString(entry.rationale);
+  const normalizedRationale = rationale?.toLowerCase().trim();
+  const noWinnerReason = readString(entry.noWinnerReason);
+  const judgeStatus2 = readString(entry.judgeStatus) ?? readString(audit.judgeStatus);
+  const error = readString(entry.error);
+  const rationaleIndicatesNonTechnical = normalizedRationale === "non-technical task" || normalizedRationale === "non_technical_task" || normalizedRationale === "judge_invalid: multi-lens skipped for non-technical task";
+  if (invalidCause === "non_technical_task" || !invalidCause && rationaleIndicatesNonTechnical) {
+    return { kind: "not-applicable", reason: "non-technical task" };
+  }
+  if (error) return { kind: "failed", reason: error };
+  if (judgeStatus2 === "judge_invalid") {
+    return {
+      kind: "failed",
+      reason: normalizeReasonLabel(invalidCause ?? "judge invalid")
+    };
+  }
+  if (normalizedRationale?.startsWith("judge_invalid:")) {
+    return {
+      kind: "failed",
+      reason: normalizeReasonLabel(invalidCause ?? "judge invalid")
+    };
+  }
+  if (noWinnerReason === "judge-error") {
+    return { kind: "failed", reason: normalizeReasonLabel(noWinnerReason) };
+  }
+  return { kind: "none" };
+}
+function buildAgreementSummary(row, results, judgesExecuted) {
+  const entries = Object.entries(results);
+  const totalCount = judgesExecuted.length > 0 ? judgesExecuted.length : entries.length;
+  const winners = entries.map(([, entry]) => ({ entry, status: classifyJudgeDisplayStatus(entry) })).filter(
+    (item) => item.status.kind === "winner"
+  );
+  const distinctWinners = new Set(winners.map(({ status }) => status.winner));
+  const normalizedModels = winners.map(({ entry }) => {
+    const audit = readJudgeAudit(entry);
+    const provider = readString(entry.provider) ?? readString(audit.llmProvider) ?? readString(audit.orchestrationProvider);
+    const model = entry.model?.trim().toLowerCase() ?? "";
+    return model ? `${provider?.toLowerCase() ?? "unknown"}:${model}` : "";
+  });
+  const correlated = normalizedModels.length >= 2 && normalizedModels.every((model) => model.length > 0 && model === normalizedModels[0]);
+  if (winners.length >= 2) {
+    return {
+      status: distinctWinners.size === 1 ? "agree" : "disagree",
+      applicableCount: winners.length,
+      totalCount,
+      correlated
+    };
+  }
+  if (entries.length === 0 && row.all_match !== null) {
+    return {
+      status: row.all_match === 1 ? "agree" : "disagree",
+      applicableCount: row.all_match === 1 ? totalCount : 0,
+      totalCount,
+      correlated: false
+    };
+  }
+  return { status: "n/a", applicableCount: winners.length, totalCount, correlated: false };
+}
+function formatAgreementLabel(summary) {
+  const label = summary.status === "agree" ? chalk3.green("agree") : summary.status === "disagree" ? chalk3.yellow("disagree") : chalk3.gray("n/a");
+  const suffix = summary.totalCount > 0 && summary.applicableCount !== summary.totalCount ? ` (${summary.applicableCount} of ${summary.totalCount} applicable)` : "";
+  const correlationSuffix = summary.correlated ? " (correlated: same model)" : "";
+  return `${label}${suffix}${correlationSuffix}`;
+}
+function formatJudgeDisplayLine(entry) {
+  const status = classifyJudgeDisplayStatus(entry);
+  const usageSuffix = formatJudgeUsageSuffix(entry);
+  const deferredSuffix = formatDeferredShadowStatus(entry);
+  if (status.kind === "winner") {
+    const suffix = entry.error ? chalk3.red(` (${entry.error})`) : "";
+    return `${status.winner}${suffix}${usageSuffix}${deferredSuffix}`;
+  }
+  if (status.kind === "not-applicable") {
+    return `not applicable (${status.reason})${usageSuffix}${deferredSuffix}`;
+  }
+  if (status.kind === "failed") {
+    return chalk3.red(`failed (${status.reason})${usageSuffix}${deferredSuffix}`);
+  }
+  if (status.kind === "skipped") {
+    return chalk3.yellow(`skipped (${status.reason})${usageSuffix}${deferredSuffix}`);
+  }
+  return `none${usageSuffix}${deferredSuffix}`;
+}
+function formatDeferredShadowStatus(entry) {
+  if (entry.deferredShadowStatus === "pending") {
+    return chalk3.yellow(" [shadow pending]");
+  }
+  if (entry.deferredShadowStatus === "reconciled") {
+    return chalk3.green(" [shadow reconciled]");
+  }
+  return "";
+}
+function formatTokens(tokensUsed) {
+  if (typeof tokensUsed !== "number" || !Number.isFinite(tokensUsed) || tokensUsed <= 0)
+    return null;
+  return tokensUsed >= 1e3 ? `${(tokensUsed / 1e3).toFixed(1)}k tok` : `${Math.round(tokensUsed)} tok`;
+}
+function formatCost(costUsd) {
+  if (typeof costUsd !== "number" || !Number.isFinite(costUsd) || costUsd < 0) return null;
+  return `$${costUsd.toFixed(4)}`;
+}
+function formatJudgeUsageSuffix(entry) {
+  const parts = [];
+  if (typeof entry.evaluationTimeMs === "number" && Number.isFinite(entry.evaluationTimeMs)) {
+    parts.push(`${Math.round(entry.evaluationTimeMs)}ms`);
+  }
+  const tokenLabel = formatTokens(entry.tokensUsed);
+  if (tokenLabel) parts.push(tokenLabel);
+  const costLabel = formatCost(entry.costUsd);
+  if (costLabel) parts.push(costLabel);
+  if (typeof entry.model === "string" && entry.model.trim()) {
+    parts.push(entry.model.trim());
+  }
+  if (typeof entry.sandboxProvenance === "string" && entry.sandboxProvenance.trim()) {
+    parts.push(`sb:${entry.sandboxProvenance}`);
+  }
+  const modeLabel = formatJudgeModeSuffix(entry);
+  if (modeLabel) parts.push(modeLabel);
+  return parts.length > 0 ? ` [${parts.join(", ")}]` : "";
+}
+function formatJudgeModeSuffix(entry) {
+  if (entry.executionMode !== "lightweight" && entry.executionMode !== "host-owned") {
+    return null;
+  }
+  const reason = typeof entry.routingReason === "string" && entry.routingReason.trim() ? ` (${entry.routingReason.trim()})` : "";
+  const pieces = [`mode=${entry.executionMode}${reason}`];
+  if (typeof entry.workerPacketCount === "number" && Number.isFinite(entry.workerPacketCount)) {
+    pieces.push(`workers=${entry.workerPacketCount}`);
+  }
+  return pieces.join(" ");
+}
+function renderAgenticSummary(summary, compact) {
+  const severity = summary.severityCounts;
+  const verification = summary.verificationCounts;
+  const headline = compact ? "agentic" : "Agentic Findings";
+  const prefix = compact ? "         " : "    ";
+  const riskTag = summary.hasCriticalOrHigh ? "critical/high present" : "no critical/high";
+  const toolsLabel = summary.topTools.length > 0 ? ` topTools=${summary.topTools.join(", ")}` : "";
+  console.log(
+    chalk3.gray(
+      `${prefix}${headline}: findings=${summary.totalFindings} (critical=${severity.critical}, high=${severity.high}, medium=${severity.medium}, low=${severity.low}, info=${severity.info}) verify=${verification.passed}/${verification.failed}/${verification.skipped}/${verification.error} deepDive=${summary.deepDiveVariants} variantsWithFindings=${summary.variantsWithFindings} tools=${summary.toolsUsedCount} ${riskTag}${toolsLabel}`
+    )
+  );
+}
+function getLatestMultiJudgeRunForTask(telemetry, taskId) {
+  try {
+    const db = telemetry.databaseModule.getVariantsDb();
+    if (!db) return null;
+    const scope = telemetry.getTelemetryScope({ includeLabs: true });
+    const row = db.prepare(
+      `
+        SELECT
+          timestamp,
+          judges_executed,
+          primary_judge,
+          primary_winner,
+          primary_winner_score,
+          primary_winner_confidence,
+          all_match,
+          results_json,
+          no_winner_reason,
+          total_variants,
+          evaluation_time_ms
+        FROM multi_judge_runs
+        WHERE ${scope.where} AND task_id = ?
+        ORDER BY timestamp DESC
+        LIMIT 1
+      `
+    ).get(...scope.params, taskId);
+    if (row) return normalizeMultiJudgeRunRow(row);
+    const fallbackRow = db.prepare(
+      `
+        SELECT
+          timestamp,
+          judges_executed,
+          primary_judge,
+          primary_winner,
+          primary_winner_score,
+          primary_winner_confidence,
+          all_match,
+          results_json,
+          no_winner_reason,
+          total_variants,
+          evaluation_time_ms
+        FROM multi_judge_runs
+        WHERE task_id = ?
+        ORDER BY timestamp DESC
+        LIMIT 1
+      `
+    ).get(taskId);
+    return fallbackRow ? normalizeMultiJudgeRunRow(fallbackRow) : null;
+  } catch {
+    return null;
+  }
+}
+function renderMultiJudgeRun(row, options = {}) {
+  row = normalizeMultiJudgeRunRow(row);
+  if (options.compact) {
+    const judgesExecuted2 = parseJudgesExecuted(row);
+    const primaryJudge2 = row.primary_judge ?? row.primaryJudge ?? null;
+    const results2 = parseResultsJson(row);
+    const agreement2 = buildAgreementSummary(row, results2, judgesExecuted2);
+    console.log(
+      chalk3.gray(
+        `      Judges: [${judgesExecuted2.join(", ")}] primary=${primaryJudge2} agreement=${formatAgreementLabel(agreement2)}`
+      )
+    );
+    const shouldShowJudgeDetails = agreement2.status !== "agree" || agreement2.applicableCount !== agreement2.totalCount;
+    if (shouldShowJudgeDetails) {
+      try {
+        const dedupWarnings = /* @__PURE__ */ new Set();
+        let agenticSummary;
+        for (const [judge, result] of Object.entries(results2)) {
+          if (!agenticSummary && result.agenticFindings) {
+            agenticSummary = result.agenticFindings;
+          }
+          for (const warning of result.warnings ?? []) {
+            dedupWarnings.add(warning);
+          }
+          console.log(chalk3.gray(`         ${judge}: ${formatJudgeDisplayLine(result)}`));
+        }
+        if (agenticSummary) {
+          renderAgenticSummary(agenticSummary, true);
+        }
+        for (const warning of dedupWarnings) {
+          console.log(chalk3.yellow(`         [WARN] ${warning}`));
+        }
+      } catch {
+      }
+    }
+    if (!shouldShowJudgeDetails) {
+      try {
+        const dedupWarnings = /* @__PURE__ */ new Set();
+        const agenticSummary = Object.values(results2).find(
+          (result) => result.agenticFindings
+        )?.agenticFindings;
+        for (const [judge, result] of Object.entries(results2)) {
+          const modeSuffix = formatJudgeModeSuffix(result);
+          const deferredSuffix = formatDeferredShadowStatus(result).trim();
+          const suffixes = [modeSuffix, deferredSuffix].filter(Boolean);
+          if (suffixes.length > 0) {
+            console.log(chalk3.gray(`         ${judge}: ${suffixes.join(" ")}`));
+          }
+        }
+        if (agenticSummary) {
+          renderAgenticSummary(agenticSummary, true);
+        }
+        for (const result of Object.values(results2)) {
+          for (const warning of result.warnings ?? []) {
+            dedupWarnings.add(warning);
+          }
+        }
+        for (const warning of dedupWarnings) {
+          console.log(chalk3.yellow(`         [WARN] ${warning}`));
+        }
+      } catch {
+      }
+    }
+    return;
+  }
+  console.log(chalk3.cyan.bold("\nMulti-Judge Run:\n"));
+  console.log(chalk3.gray(`  Timestamp: ${row.timestamp}`));
+  const judgesExecuted = parseJudgesExecuted(row);
+  console.log(chalk3.white(`  Judges: ${judgesExecuted.join(", ")}`));
+  const primaryJudge = row.primary_judge ?? row.primaryJudge ?? null;
+  const primaryWinner = row.primary_winner ?? row.primaryWinner ?? null;
+  if (primaryJudge) console.log(chalk3.white(`  Primary: ${primaryJudge}`));
+  if (primaryWinner) console.log(chalk3.white(`  Primary Winner: ${primaryWinner}`));
+  const results = parseResultsJson(row);
+  const agreement = buildAgreementSummary(row, results, judgesExecuted);
+  printLine(chalk3.white(`  Agreement: ${formatAgreementLabel(agreement)}`));
+  if (agreement.totalCount > 0) {
+    printLine(chalk3.white(`  Applicable: ${agreement.applicableCount} of ${agreement.totalCount}`));
+  }
+  if (row.total_variants !== null) {
+    console.log(chalk3.white(`  Variants: ${row.total_variants}`));
+  }
+  if (row.evaluation_time_ms !== null) {
+    console.log(chalk3.white(`  Evaluation Time: ${row.evaluation_time_ms.toFixed(0)}ms`));
+  }
+  if (row.no_winner_reason) {
+    console.log(chalk3.yellow(`  No Winner Reason: ${row.no_winner_reason}`));
+  }
+  try {
+    const dedupWarnings = /* @__PURE__ */ new Set();
+    console.log(chalk3.white("\n  Results:"));
+    for (const [judge, result] of Object.entries(results)) {
+      for (const warning of result.warnings ?? []) {
+        dedupWarnings.add(warning);
+      }
+      console.log(chalk3.gray(`    ${judge}: ${formatJudgeDisplayLine(result)}`));
+      if (result.executionMode === "lightweight" || result.executionMode === "host-owned") {
+        const reason = typeof result.routingReason === "string" && result.routingReason.trim().length > 0 ? ` (${result.routingReason.trim()})` : "";
+        console.log(chalk3.gray(`      mode: ${result.executionMode}${reason}`));
+        if (typeof result.workerPacketCount === "number" && Number.isFinite(result.workerPacketCount)) {
+          console.log(chalk3.gray(`      workerPackets: ${result.workerPacketCount}`));
+        }
+      }
+      if (result.agenticFindings) {
+        renderAgenticSummary(result.agenticFindings, false);
+      }
+    }
+    for (const warning of dedupWarnings) {
+      console.log(chalk3.yellow(`    [WARN] ${warning}`));
+    }
+  } catch {
+  }
+  console.log();
+}
+
+// src/cli/utils/results-intent-tokens.ts
+function formatFusionFallbackContribution(success) {
+  if (success === true) return "completed";
+  if (success === false) return "not_completed";
+  return "unknown";
+}
+function isAnalysisIntentToken(value) {
+  return typeof value === "string" && value.trim().replace(/_/g, "-") === "analysis";
+}
+function isAnalysisIntentSkipReason(value) {
+  return typeof value === "string" && value.trim().replace(/_/g, "-") === "analysis-intent";
+}
+
+// src/cli/commands/compete-results-ignored-artifacts.ts
+import chalk4 from "chalk";
+function normaliseIgnoredPathEvidence(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const record = value;
+  const paths = Array.isArray(record.paths) ? record.paths.filter((path3) => typeof path3 === "string" && path3.length > 0) : [];
+  if (paths.length === 0) return null;
+  return {
+    paths,
+    ...typeof record.reason === "string" ? { reason: record.reason } : {},
+    ...typeof record.source === "string" ? { source: record.source } : {}
+  };
+}
+function extractIgnoredArtifactPaths(candidateRecord) {
+  const evidence2 = normaliseIgnoredPathEvidence(candidateRecord.ignoredPathEvidence);
+  const paths = Array.isArray(evidence2?.paths) ? evidence2.paths : [];
+  return paths.filter((path3) => typeof path3 === "string" && path3.length > 0);
+}
+function formatIgnoredArtifactLine(paths) {
+  if (paths.length === 0) return null;
+  const preview = paths.slice(0, 5);
+  const suffix = paths.length > preview.length ? ` (+${paths.length - preview.length} more)` : "";
+  return `Ignored artifacts: ${preview.join(", ")}${suffix}`;
+}
+function printCandidateEvidenceLines(record) {
+  const alsoOnBase = record?.alsoFailingOnBase;
+  if (Array.isArray(alsoOnBase) && alsoOnBase.length > 0) {
+    console.log(chalk4.gray(`    Also failing on base: ${alsoOnBase.join(", ")}`));
+  }
+  const line = record ? formatIgnoredArtifactLine(extractIgnoredArtifactPaths(record)) : null;
+  if (line) console.log(chalk4.gray(`    ${line}`));
+}
+
+// src/cli/commands/compete-results-not-found.ts
+import chalk5 from "chalk";
+function buildNoEvaluationFoundHints(surface, taskId) {
+  let runTask = null;
+  try {
+    runTask = readRunTaskState(taskId);
+  } catch {
+    runTask = null;
+  }
+  if (runTask?.artifact && runTask.providerOutputArtifactRelativePath) {
+    return [
+      `${taskId} is a single-pass build run task (status: ${runTask.status}); single-pass tasks have no ${surface === "fusion" ? "fusion" : "competition"} results.`,
+      `Inspect it with: build monitor ${taskId}`,
+      `Provider output artifact: ${runTask.providerOutputArtifactRelativePath}`
+    ];
+  }
+  const competitionsDir = `${resolveCliStateRoots().competitionsDir}/`;
+  const stateLocations = surface === "fusion" ? `.build-project/analysis-synthesis/ or ${competitionsDir}` : competitionsDir;
+  return [
+    `Run build monitor ${taskId} to see whether this id belongs to a single-pass task or another run kind.`,
+    `Check that the task id matches a file under ${stateLocations}.`
+  ];
+}
+function renderNoEvaluationFoundError(surface, taskId) {
+  console.error(chalk5.red(`
+Error: No evaluation found for task ID: ${taskId}`));
+  for (const hint of buildNoEvaluationFoundHints(surface, taskId)) {
+    console.error(chalk5.gray(`Hint: ${hint}`));
+  }
+  console.error();
+}
+
+// src/cli/commands/compete-results.ts
+var SCORE_CALIBRATION_DISPLAY_DELTA_THRESHOLD = 0.1;
+function hasCompetitionStateData(state) {
+  return state.sources.competitionHandle.exists || state.sources.backgroundHandle.exists;
+}
+var resolveExecutionHealthFromState = resolveExecutionHealthFromCompetitionState;
+var resolveCompetitionResultFromState = resolveCompetitionResultFromCompetitionState;
+var getRawCompetitionCandidates = getRawCompetitionCandidatesFromCompetitionState;
+function getFusionRunReadModel(runId, options) {
+  const runSnapshotV1 = getRunSnapshotV1(runId, options);
+  const runProgressV1 = runSnapshotV1 === null ? null : projectRunProgress(runSnapshotV1);
+  const operationalReadbackV1 = runSnapshotV1 === null ? null : toFusionOperationalReadbackV1(runSnapshotV1);
+  let narrationConfig;
+  let narrationConfigurationError;
+  try {
+    narrationConfig = resolveProgressNarrationConfig(options?.cwd ?? process.cwd());
+  } catch {
+    narrationConfig = void 0;
+    narrationConfigurationError = "Progress narration configuration could not be resolved.";
+  }
+  return {
+    runSnapshotV1,
+    runProgressV1,
+    operationalReadbackV1,
+    runNarrationRequestV1: runProgressV1 === null ? null : buildRunNarrationRequestV1(runProgressV1, narrationConfig?.value, {
+      configurationError: narrationConfigurationError
+    })
+  };
+}
+function getCompetitionRunReadModel(runId, options) {
+  const operationalReadbackV1 = getCompetitionOperationalReadbackV1(runId, options);
+  const snapshot = operationalReadbackV1?.competition ?? null;
+  return {
+    operationalReadbackV1,
+    // The same provider-neutral progress projection Fusion already publishes.
+    // BB renders it; it never reconstructs variant state from competition prose.
+    runProgressV1: snapshot === null ? null : projectRunProgress(snapshot)
+  };
+}
+function hasAnalysisIntentEvidence(state, candidates) {
+  if (isAnalysisIntentToken(state?.runMetadata?.replay?.executionIntent)) return true;
+  return candidates.some((candidate) => {
+    if (isAnalysisIntentToken(candidate.executionIntent)) return true;
+    const testsExecuted = candidate.testsExecuted && typeof candidate.testsExecuted === "object" ? candidate.testsExecuted : null;
+    return isAnalysisIntentSkipReason(testsExecuted?.skipReason);
+  });
+}
+function sanitizeFusionContributorOutcome(outcome) {
+  if (!outcome || typeof outcome !== "object" || Array.isArray(outcome)) return outcome ?? null;
+  const record = outcome;
+  const delivery = record.delivery && typeof record.delivery === "object" && !Array.isArray(record.delivery) ? { ...record.delivery } : void 0;
+  if (delivery) {
+    delete delivery.score;
+  }
+  return {
+    ...record,
+    ...delivery ? { delivery } : {}
+  };
+}
+function buildCompetitionHandleVariantJson(c, options = {}) {
+  const isFusion = options.runSemantics === "fusion";
+  const inputSpecWarning = normaliseInputSpecWarning(c.inputSpecWarning);
+  const ignoredPathEvidence = normaliseIgnoredPathEvidence(c.ignoredPathEvidence);
+  return {
+    provider: c.provider ?? null,
+    requestedProvider: c.requestedProvider ?? null,
+    model: c.model ?? null,
+    requestedModel: c.requestedModel ?? null,
+    resolvedModel: c.resolvedModel ?? null,
+    modelResolutionSource: c.modelResolutionSource ?? null,
+    failoverFromProvider: c.failoverFromProvider ?? null,
+    failoverReason: c.failoverReason ?? null,
+    strategy: c.strategy ?? null,
+    variant: c.variant ?? null,
+    workspaceMode: c.workspaceMode ?? null,
+    workspaceModeRequested: c.workspaceModeRequested ?? null,
+    reasoningEffort: c.reasoningEffort ?? null,
+    cursorPromptProfile: c.cursorPromptProfile ?? null,
+    outcome: isFusion ? sanitizeFusionContributorOutcome(c.outcome) : c.outcome ?? null,
+    success: c.success ?? null,
+    ...isFusion ? { contribution: formatFusionFallbackContribution(c.success) } : { completeness: c.completeness ?? null },
+    duration: c.duration ?? null,
+    terminationReason: c.terminationReason ?? null,
+    timedOut: c.timedOut ?? null,
+    errorMessage: c.errorMessage ?? null,
+    ...typeof c.warningCount === "number" ? { warningCount: c.warningCount } : {},
+    ...Array.isArray(c.warnings) ? { warnings: c.warnings } : {},
+    cloudTaskId: c.cloudTaskId ?? null,
+    submittedOnly: c.submittedOnly ?? null,
+    prNumber: c.prNumber ?? null,
+    prUrl: c.prUrl ?? null,
+    ...inputSpecWarning ? { inputSpecWarning } : {},
+    ...ignoredPathEvidence ? { ignoredPathEvidence } : {}
+  };
+}
+function stringField(record, key) {
+  const value = record[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function resultVariantRowMatchesFinalWinner(row, finalWinnerVariant) {
+  const provider = stringField(row, "provider");
+  const strategy = stringField(row, "strategy");
+  const model = stringField(row, "model");
+  const resolvedModel = stringField(row, "resolvedModel");
+  const executionMode = stringField(row, "executionMode");
+  const aliases = [
+    stringField(row, "variant"),
+    provider && model ? `${provider}:${model}` : null,
+    provider && resolvedModel ? `${provider}:${resolvedModel}` : null,
+    // Persisted rows written before the strategy axis was removed reconstruct
+    // their variant key from the historical grammar.
+    provider && strategy ? `${provider}:${strategy}` : null,
+    provider && model && strategy ? `${provider}:${model}:${strategy}` : null,
+    provider && resolvedModel && strategy ? `${provider}:${resolvedModel}:${strategy}` : null,
+    provider && strategy && executionMode ? `${provider}:${strategy}:${executionMode}` : null,
+    provider && model && strategy && executionMode ? `${provider}:${model}:${strategy}:${executionMode}` : null,
+    provider && resolvedModel && strategy && executionMode ? `${provider}:${resolvedModel}:${strategy}:${executionMode}` : null
+  ];
+  return aliases.some((alias) => variantHandlesMatchForResults(alias, finalWinnerVariant));
+}
+function findDecisionCandidateForResults(candidates, selectedVariant, winnerVariant) {
+  const candidateVariant = typeof selectedVariant === "string" && selectedVariant.trim().length > 0 ? selectedVariant : typeof winnerVariant === "string" && winnerVariant.trim().length > 0 ? winnerVariant : null;
+  if (!candidateVariant) {
+    return null;
+  }
+  return candidates.find(
+    (candidate) => resultVariantRowMatchesFinalWinner(candidate, candidateVariant)
+  ) ?? null;
+}
+function buildFallbackJudgeSummary(state) {
+  const runJudge = state.runMetadata?.judge;
+  const decision = state.decision;
+  if (!runJudge && !decision) return null;
+  const status = runJudge?.status ?? (decision?.reason === "judge_off" ? "disabled" : decision?.decisionStatus ? "completed" : null);
+  return {
+    requested: runJudge?.requested ?? decision?.primaryJudge ?? null,
+    status,
+    ...decision?.reason ? { reason: decision.reason } : {},
+    ...decision?.decisionStatus ? { decisionStatus: decision.decisionStatus } : {},
+    ...decision?.decisionOutcome ? { decisionOutcome: decision.decisionOutcome } : {},
+    ...decision?.selectedVariant ? { selectedVariant: decision.selectedVariant } : {},
+    ...decision?.primaryJudge ? { primaryJudge: decision.primaryJudge } : {}
+  };
+}
+function buildFallbackDecisionSummary(state) {
+  const decision = state.decision;
+  if (!decision) return null;
+  return {
+    outcome: decision.outcome ?? null,
+    reason: decision.reason ?? null,
+    decisionStatus: decision.decisionStatus ?? null,
+    decisionOutcome: decision.decisionOutcome ?? null,
+    selectedVariant: decision.selectedVariant ?? null,
+    primaryJudge: decision.primaryJudge ?? null
+  };
+}
+function hasEvaluationVariantScores(evaluation) {
+  return Boolean(evaluation?.variantScores && Object.keys(evaluation.variantScores).length > 0);
+}
+function getStoredEvaluationTaskId(evaluation) {
+  const taskId = evaluation?.taskId;
+  return typeof taskId === "string" && taskId.trim().length > 0 ? taskId : null;
+}
+var AmbiguousLabTaskIdError = class extends Error {
+  constructor(requestedTaskId, matches, matchType) {
+    super(
+      `Ambiguous lab task ID prefix "${requestedTaskId}" matched ${matches.length} state files. Use a longer task ID. Matches: ${matches.map((match) => `${match.taskId} (${path2.relative(process.cwd(), match.runRoot)})`).join(", ")}`
+    );
+    this.requestedTaskId = requestedTaskId;
+    this.matches = matches;
+    this.matchType = matchType;
+    this.name = "AmbiguousLabTaskIdError";
+  }
+  requestedTaskId;
+  matches;
+  matchType;
+  toJson() {
+    return {
+      error: this.message,
+      code: "ambiguous_lab_task_id",
+      taskId: this.requestedTaskId,
+      matchType: this.matchType,
+      matches: this.matches.map((match) => ({
+        taskId: match.taskId,
+        runRoot: match.runRoot
+      }))
+    };
+  }
+};
+function findLabRunStateForTask2(buildDir, taskId) {
+  const exact = findLabRunStateForTask(taskId, buildDir);
+  if (exact) {
+    return { runRoot: exact.runPath, taskId: exact.taskId };
+  }
+  const prefixMatches = /* @__PURE__ */ new Map();
+  for (const { runPath: runRoot } of listLabRunDirs(buildDir)) {
+    for (const subdir of ["competitions", "background"]) {
+      const stateDir = path2.join(runRoot, "state", subdir);
+      if (!fs.existsSync(stateDir)) {
+        continue;
+      }
+      for (const entry of fs.readdirSync(stateDir)) {
+        if (!entry.endsWith(".json") || !entry.startsWith(`${taskId}-`)) {
+          continue;
+        }
+        const resolvedTaskId = entry.slice(0, -".json".length);
+        prefixMatches.set(`${runRoot}\0${resolvedTaskId}`, {
+          runRoot,
+          taskId: resolvedTaskId
+        });
+      }
+    }
+  }
+  const matches = [...prefixMatches.values()];
+  if (matches.length > 1) {
+    throw new AmbiguousLabTaskIdError(taskId, matches, "prefix");
+  }
+  return matches[0] ?? null;
+}
+function buildLabStateReaderOptions(runRoot) {
+  const stateRoot = path2.join(runRoot, "state");
+  return {
+    stateDir: path2.join(stateRoot, "competitions"),
+    backgroundDir: path2.join(stateRoot, "background"),
+    unifiedStateDir: stateRoot
+  };
+}
+function resolveCompetitionResultsTaskId(options) {
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pushCandidate = (taskId) => {
+    if (typeof taskId !== "string") return;
+    const trimmed = taskId.trim();
+    if (trimmed.length === 0 || seen.has(trimmed)) return;
+    seen.add(trimmed);
+    candidates.push(trimmed);
+  };
+  pushCandidate(options.requestedTaskId);
+  pushCandidate(options.evaluationTaskId);
+  for (const taskId of options.judgeEvaluationTaskIds ?? []) {
+    pushCandidate(taskId);
+  }
+  if (!/-st\d+$/.test(options.requestedTaskId)) {
+    pushCandidate(`${options.requestedTaskId}-st1`);
+  }
+  for (const candidate of candidates) {
+    if (options.hasCompetitionState(candidate)) {
+      return candidate;
+    }
+  }
+  const storedEvaluationTaskId = [
+    options.evaluationTaskId,
+    ...options.judgeEvaluationTaskIds ?? []
+  ].map((taskId) => typeof taskId === "string" ? taskId.trim() : "").find((taskId) => taskId.length > 0);
+  return storedEvaluationTaskId ?? options.requestedTaskId;
+}
+function getPrimaryWinnerScoreForCalibration(report, multiJudgeRun) {
+  return typeof multiJudgeRun?.primary_winner_score === "number" && Number.isFinite(multiJudgeRun.primary_winner_score) ? multiJudgeRun.primary_winner_score : report.judgeSelectedTopPick.score;
+}
+function renderInterruptedCompetitionNotice(state) {
+  const line = formatInterruptedCompetitionNotice(state);
+  if (!line) return;
+  console.log(chalk6.yellow(line));
+  console.log();
+}
+function formatWinnerReconciliationHuman(report, multiJudgeRun) {
+  if (!report.hasTelemetry) return;
+  const j = report.judgeSelectedTopPick.variant;
+  const r = report.finalRetainedWinner.variant;
+  const jScore = typeof report.judgeSelectedTopPick.score === "number" ? ` (${report.judgeSelectedTopPick.score.toFixed(1)})` : "";
+  const rScore = typeof report.finalRetainedWinner.score === "number" ? ` (${report.finalRetainedWinner.score.toFixed(1)})` : "";
+  console.log(chalk6.cyan.bold("Winner reconciliation"));
+  if (report.competitionOutcome) {
+    console.log(chalk6.gray(`  Competition outcome: ${report.competitionOutcome}`));
+  }
+  if (!j) {
+    console.log(chalk6.gray("  Judge-selected top pick: (none)"));
+  } else {
+    console.log(chalk6.white(`  Judge-selected top pick: ${j}${jScore}`));
+  }
+  if (!r) {
+    console.log(
+      chalk6.gray("  Final retained winner: (none \u2014 competition outcome did not retain a winner)")
+    );
+  } else {
+    console.log(chalk6.white(`  Final retained winner: ${r}${rScore}`));
+  }
+  if (report.requiredGatePolicy) {
+    console.log(chalk6.white(`  Required gate policy: ${report.requiredGatePolicy}`));
+  }
+  if (report.detectedTaskType) {
+    console.log(chalk6.white(`  Detected task type: ${report.detectedTaskType}`));
+  }
+  if (report.multiJudgePrimaryWinner) {
+    const aligned = report.multiJudgePrimaryAlignedWithFinal === null ? "" : report.multiJudgePrimaryAlignedWithFinal ? chalk6.green(" (matches final retained)") : chalk6.yellow(" (differs from final retained)");
+    console.log(
+      chalk6.white(`  Multi-judge primary winner: ${report.multiJudgePrimaryWinner}${aligned}`)
+    );
+  }
+  const primaryWinnerScore = getPrimaryWinnerScoreForCalibration(report, multiJudgeRun);
+  const scoreDelta = typeof primaryWinnerScore === "number" && typeof report.finalRetainedWinner.score === "number" ? primaryWinnerScore - report.finalRetainedWinner.score : null;
+  if (scoreDelta != null && Math.abs(scoreDelta) >= SCORE_CALIBRATION_DISPLAY_DELTA_THRESHOLD) {
+    console.log(chalk6.white(`  Primary-vs-final score delta: ${scoreDelta.toFixed(1)}`));
+  }
+  if (report.multiLensWinnerFlip) {
+    const f = report.multiLensWinnerFlip;
+    console.log(
+      chalk6.gray(
+        `  Multi-lens winner flip: ${f.rawWinner} \u2192 ${f.finalWinner}${f.reason ? ` \u2014 ${f.reason}` : ""}`
+      )
+    );
+  }
+  if (report.judgedWinnerNotRetainedReason) {
+    console.log(
+      chalk6.yellow(`  Judged winner not retained: ${report.judgedWinnerNotRetainedReason}`)
+    );
+  } else if (j && r && report.reconciliationStatus === "aligned") {
+    console.log(chalk6.green("  Judge pick matches final retained winner."));
+  } else if (!j && !r) {
+    console.log(chalk6.gray("  No judge pick or retained winner recorded for reconciliation."));
+  }
+  console.log();
+}
+function normalizeMatrixProfileDecision(input) {
+  if (input.profileDecision === "unanimous" || input.profileDecision === "split" || input.profileDecision === "inconclusive") {
+    return input.profileDecision;
+  }
+  if (input.winnerStatus === "inconclusive") return "inconclusive";
+  if (typeof input.profilesDisagree === "boolean") {
+    return input.profilesDisagree ? "split" : "unanimous";
+  }
+  return "unknown";
+}
+function matrixSummaryFromStateMetadata(matrix) {
+  if (!matrix || matrix.autoRun !== true) return null;
+  return {
+    matrixAutoRun: true,
+    matrixEvaluatorType: matrix.evaluatorType,
+    matrixProfiles: matrix.profiles,
+    matrixWinnerStatus: matrix.winnerStatus,
+    matrixProfilesDisagree: matrix.profilesDisagree,
+    matrixProfileDecision: normalizeMatrixProfileDecision({
+      profileDecision: matrix.profileDecision,
+      winnerStatus: matrix.winnerStatus,
+      profilesDisagree: matrix.profilesDisagree
+    }),
+    blockingHumanChecks: [],
+    advisoryHumanChecks: [
+      ...matrix.escalationReasons?.length ? [`Escalation reasons: ${matrix.escalationReasons.join(", ")}`] : [],
+      ...matrix.winnerCaveats ?? []
+    ]
+  };
+}
+function getSelectedEvaluationKind(evaluation) {
+  if (!evaluation) return "unknown";
+  const rationale = evaluation.winnerRationale;
+  if (rationale && typeof rationale === "object" && rationale.mode === "profile-matrix") {
+    return "profile-matrix";
+  }
+  const evaluationId = evaluation.evaluationId;
+  if (typeof evaluationId === "string" && evaluationId.includes("profile-matrix")) {
+    return "profile-matrix";
+  }
+  const judgeType = evaluation.judgeType;
+  return typeof judgeType === "string" ? judgeType : "unknown";
+}
+function formatJudgeEvaluationModelLine(evaluation) {
+  const label = judgeModelLabel(evaluation.model, evaluation.reportedModel);
+  return label ? `  Model: ${label}` : void 0;
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function uniqueEvaluationsForWinnerEvidence(selectedEvaluation, judgeEvaluations) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const evaluation of [selectedEvaluation, ...judgeEvaluations]) {
+    const stored = evaluation;
+    const key = typeof stored.evaluationId === "string" ? `id:${stored.evaluationId}` : `content:${stored.judgeType ?? "unknown"}:${stored.model ?? ""}:${stored.winnerVariant ?? ""}:${stored.winnerScore ?? ""}:${stored.winnerConfidence ?? ""}:${Object.keys(
+      stored.variantScores ?? {}
+    ).sort().join("|")}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(evaluation);
+  }
+  return result;
+}
+function evaluationWinnerMatchesFinal(evaluation, finalWinnerVariant) {
+  return Boolean(
+    finalWinnerVariant && evaluation?.winnerVariant && variantHandlesMatchForResults(evaluation.winnerVariant, finalWinnerVariant)
+  );
+}
+function resolveWinnerEvidenceForResults(options) {
+  const {
+    finalWinnerVariant,
+    selectedEvaluation,
+    judgeEvaluations,
+    multiJudgeRun,
+    winnerReconciliation
+  } = options;
+  const selectedKind = getSelectedEvaluationKind(selectedEvaluation);
+  const primaryJudge = multiJudgeRun?.primary_judge?.trim() || null;
+  const evaluations = uniqueEvaluationsForWinnerEvidence(selectedEvaluation, judgeEvaluations);
+  const matchingEvaluations = evaluations.filter(
+    (entry) => getSelectedEvaluationKind(entry) !== "profile-matrix" && evaluationWinnerMatchesFinal(entry, finalWinnerVariant)
+  );
+  const primaryEvaluation = primaryJudge != null ? matchingEvaluations.find(
+    (entry) => entry.judgeType === primaryJudge
+  ) : void 0;
+  const selectedMatchesFinal = getSelectedEvaluationKind(selectedEvaluation) !== "profile-matrix" && evaluationWinnerMatchesFinal(selectedEvaluation, finalWinnerVariant);
+  const selectedWinnerEvaluation = selectedMatchesFinal ? selectedEvaluation : void 0;
+  const winnerEvaluation = primaryEvaluation ?? selectedWinnerEvaluation ?? matchingEvaluations.at(0) ?? null;
+  if (winnerEvaluation) {
+    const score = scoreForVariant(winnerEvaluation, finalWinnerVariant) ?? (isFiniteNumber(winnerEvaluation.winnerScore) ? winnerEvaluation.winnerScore : null);
+    const source = winnerEvaluation === primaryEvaluation ? "primary_judge" : winnerEvaluation === selectedWinnerEvaluation ? "selected_evaluation" : "judge_row";
+    return {
+      score,
+      decisionScore: score,
+      confidence: isFiniteNumber(winnerEvaluation.winnerConfidence) ? winnerEvaluation.winnerConfidence : null,
+      rationale: winnerEvaluation.winnerRationale ?? null,
+      scoreSource: source,
+      provenance: source === "primary_judge" ? "competition_handle; primary judge evaluation aligned" : "competition_handle; judge evaluation aligned"
+    };
+  }
+  if (winnerReconciliation.multiJudgePrimaryAlignedWithFinal === true) {
+    const score = (isFiniteNumber(multiJudgeRun?.primary_winner_score) ? multiJudgeRun.primary_winner_score : null) ?? winnerReconciliation.judgeSelectedTopPick.score;
+    return {
+      score,
+      decisionScore: score,
+      confidence: isFiniteNumber(multiJudgeRun?.primary_winner_confidence) ? multiJudgeRun.primary_winner_confidence : null,
+      rationale: null,
+      scoreSource: "primary_judge",
+      provenance: "competition_handle; primary judge telemetry aligned"
+    };
+  }
+  if (winnerReconciliation.finalRetainedWinner.score != null) {
+    return {
+      score: winnerReconciliation.finalRetainedWinner.score,
+      decisionScore: winnerReconciliation.finalRetainedWinner.score,
+      confidence: null,
+      rationale: null,
+      scoreSource: "reconciliation",
+      provenance: "competition_handle; score recovered from reconciliation"
+    };
+  }
+  const scoreSource = winnerReconciliation.reconciliationStatus === "handle_differs_from_judge_row" ? "handle_drift" : selectedKind === "profile-matrix" ? "matrix_advisory" : "unavailable";
+  return {
+    score: null,
+    decisionScore: null,
+    confidence: null,
+    rationale: null,
+    scoreSource,
+    provenance: scoreSource === "handle_drift" ? "competition_handle; final retained winner differs from judge row handle" : selectedKind === "profile-matrix" ? "competition_handle; selected evaluation is advisory matrix" : "competition_handle; judge evaluation winner unavailable"
+  };
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function readLatestProfileMatrixSummary(options) {
+  const matrixEvaluation = options.evaluations.filter((entry) => {
+    const rationale2 = entry.winnerRationale;
+    return entry.evaluationId.includes("-profile-matrix-") || isRecord(rationale2) && rationale2.mode === "profile-matrix";
+  }).sort(
+    (left, right) => String(right.createdAt ?? "").localeCompare(String(left.createdAt ?? ""))
+  ).at(0);
+  const rationale = matrixEvaluation?.winnerRationale;
+  if (!matrixEvaluation || !isRecord(rationale) || typeof rationale.artifactPath !== "string") {
+    return null;
+  }
+  for (const telemetryDir of options.telemetryDirs) {
+    const artifactPath = path2.join(telemetryDir, rationale.artifactPath);
+    if (!fs.existsSync(artifactPath)) continue;
+    let raw;
+    try {
+      raw = parseJsonWithContext(
+        fs.readFileSync(artifactPath, "utf8"),
+        `Profile matrix artifact at ${artifactPath}`
+      );
+    } catch {
+      continue;
+    }
+    const payload = isRecord(raw) ? raw : {};
+    const result = isRecord(payload.result) ? payload.result : payload;
+    const disagreements = isRecord(result.disagreements) ? result.disagreements : {};
+    const diagnostics = isRecord(result.diagnostics) ? result.diagnostics : {};
+    const winnerByProfile = isRecord(disagreements.winnerByProfile) ? Object.fromEntries(
+      Object.entries(disagreements.winnerByProfile).filter(
+        (entry) => typeof entry[1] === "string"
+      )
+    ) : void 0;
+    const blockingHumanChecks = Array.isArray(diagnostics.blockingHumanChecks) ? diagnostics.blockingHumanChecks.filter(
+      (entry) => typeof entry === "string"
+    ) : [];
+    const advisoryHumanChecks = Array.isArray(diagnostics.advisoryHumanChecks) ? diagnostics.advisoryHumanChecks.filter(
+      (entry) => typeof entry === "string"
+    ) : [];
+    return {
+      matrixAutoRun: true,
+      matrixEvaluatorType: typeof result.matrixEvaluatorType === "string" ? result.matrixEvaluatorType : void 0,
+      matrixProfiles: winnerByProfile,
+      matrixWinnerStatus: typeof result.winnerStatus === "string" ? result.winnerStatus : void 0,
+      matrixProfilesDisagree: typeof disagreements.profilesDisagree === "boolean" ? disagreements.profilesDisagree : void 0,
+      matrixProfileDecision: normalizeMatrixProfileDecision({
+        winnerStatus: result.winnerStatus,
+        profilesDisagree: disagreements.profilesDisagree
+      }),
+      blockingHumanChecks,
+      advisoryHumanChecks: [
+        ...Array.isArray(result.winnerCaveats) ? result.winnerCaveats.filter((entry) => typeof entry === "string") : [],
+        ...advisoryHumanChecks
+      ]
+    };
+  }
+  return null;
+}
+function formatMatrixProfilesForResults(profiles) {
+  if (!profiles || Object.keys(profiles).length === 0) return "n/a";
+  return Object.entries(profiles).map(([profile, winner]) => `${profile}=${winner}`).join(", ");
+}
+function renderMatrixResultsSummary(summary) {
+  if (!summary) return;
+  console.log(chalk6.cyan.bold("Matrix Escalation:"));
+  console.log(chalk6.white("  matrixAutoRun: true"));
+  if (summary.matrixEvaluatorType) {
+    console.log(chalk6.white(`  matrixEvaluatorType: ${summary.matrixEvaluatorType}`));
+  }
+  console.log(
+    chalk6.white(`  matrixProfiles: ${formatMatrixProfilesForResults(summary.matrixProfiles)}`)
+  );
+  if (summary.matrixWinnerStatus) {
+    console.log(chalk6.white(`  matrixWinnerStatus: ${summary.matrixWinnerStatus}`));
+  }
+  if (typeof summary.matrixProfilesDisagree === "boolean") {
+    console.log(chalk6.white(`  matrixProfilesDisagree: ${summary.matrixProfilesDisagree}`));
+    console.log(chalk6.white(`  matrixProfileDecision: ${summary.matrixProfileDecision}`));
+  }
+  if (summary.blockingHumanChecks.length > 0) {
+    console.log(chalk6.white("  Conditional checks:"));
+    for (const check of summary.blockingHumanChecks) {
+      console.log(chalk6.gray(`    - ${check}`));
+    }
+  }
+  if (summary.advisoryHumanChecks.length > 0) {
+    console.log(chalk6.white("  Advisory checks:"));
+    for (const check of summary.advisoryHumanChecks) {
+      console.log(chalk6.gray(`    - ${check}`));
+    }
+  }
+  console.log();
+}
+function buildScoreCalibrationSummary(options) {
+  const primaryWinner = options.report.multiJudgePrimaryWinner;
+  const finalWinner = options.report.finalRetainedWinner.variant;
+  const primaryWinnerScore = getPrimaryWinnerScoreForCalibration(
+    options.report,
+    options.multiJudgeRun
+  );
+  const finalWinnerScore = options.report.finalRetainedWinner.score;
+  const primaryAlignedWithFinal = primaryWinner && finalWinner ? variantHandlesMatchForResults(primaryWinner, finalWinner) : options.report.multiJudgePrimaryAlignedWithFinal;
+  const scoreDeltaPrimaryMinusFinal = typeof primaryWinnerScore === "number" && typeof finalWinnerScore === "number" ? primaryWinnerScore - finalWinnerScore : null;
+  return {
+    primaryJudge: options.multiJudgeRun?.primary_judge ?? null,
+    primaryWinner,
+    primaryWinnerScore,
+    finalWinner,
+    finalWinnerScore,
+    primaryAlignedWithFinal,
+    scoreDeltaPrimaryMinusFinal
+  };
+}
+function formatConfidencePercent(value) {
+  const percent = value <= 1 ? value * 100 : value;
+  return `${percent.toFixed(2)}%`;
+}
+var WARNING_VERBOSITY_VALUES = ["silent", "minimal", "normal", "verbose"];
+function resolveWarningVerbosity(input, source) {
+  if (typeof input !== "string") {
+    throw new Error(`Invalid warning verbosity from ${source}`);
+  }
+  if (WARNING_VERBOSITY_VALUES.includes(input)) {
+    return input;
+  }
+  throw new Error(
+    `Invalid warning verbosity "${input}" from ${source}. Expected one of: ${WARNING_VERBOSITY_VALUES.join(", ")}`
+  );
+}
+function getDisplayableSelfConfidence(entry) {
+  if (entry.confidenceSource === "decision_fallback") {
+    return void 0;
+  }
+  return typeof entry.confidence === "number" && Number.isFinite(entry.confidence) ? entry.confidence : void 0;
+}
+function resolveProviderDisplayLabel(providerId) {
+  const normalized = providerId.trim();
+  if (normalized.length === 0) {
+    return "Provider";
+  }
+  try {
+    const config = getProviderConfig(normalized);
+    const displayName = typeof config.display_name === "string" && config.display_name.trim().length > 0 ? config.display_name.trim() : typeof config.name === "string" && config.name.trim().length > 0 ? config.name.trim() : "";
+    if (displayName.length > 0) {
+      return displayName;
+    }
+  } catch {
+  }
+  return normalized.charAt(0).toUpperCase() + normalized.slice(1);
+}
+function formatProviderExecutionPathLine(variant, resultRecord) {
+  const executionPath = typeof resultRecord?.executionPath === "string" ? resultRecord.executionPath.trim() : "";
+  if (executionPath.length === 0) {
+    return null;
+  }
+  const providerId = variant.split(":")[0] ?? "";
+  const providerLabel = resolveProviderDisplayLabel(providerId);
+  const fallbackReason = typeof resultRecord?.fallbackReason === "string" ? resultRecord.fallbackReason.trim() : "";
+  return fallbackReason.length > 0 ? `${providerLabel} Execution: ${executionPath} (${fallbackReason})` : `${providerLabel} Execution: ${executionPath}`;
+}
+function toSafeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function candidateHasFailingVerificationForDisplay(candidateRecord, requiredGatePolicy) {
+  return getDisplayVerificationVerdict(candidateRecord, { requiredGatePolicy }).failed;
+}
+function shouldRenderUnretainedJudgeTopPick(input) {
+  return !input.hasFinalWinner && Boolean(input.evaluationWinnerVariant) && input.decisionReason !== "judge_off";
+}
+function extractPartialEditStats(candidateRecord) {
+  const filesChangedDirect = toSafeNumber(candidateRecord.filesChanged);
+  const linesAddedDirect = toSafeNumber(candidateRecord.linesAdded);
+  const linesRemovedDirect = toSafeNumber(candidateRecord.linesRemoved);
+  const gitMetrics = typeof candidateRecord.gitMetrics === "object" && candidateRecord.gitMetrics !== null ? candidateRecord.gitMetrics : null;
+  const worktreeSummary = typeof candidateRecord.worktreeSummary === "object" && candidateRecord.worktreeSummary !== null ? candidateRecord.worktreeSummary : null;
+  const filesChanged = filesChangedDirect ?? toSafeNumber(gitMetrics?.filesChanged) ?? toSafeNumber(worktreeSummary?.filesChanged) ?? 0;
+  const linesAdded = linesAddedDirect ?? toSafeNumber(gitMetrics?.linesAdded) ?? toSafeNumber(worktreeSummary?.insertions) ?? 0;
+  const linesRemoved = linesRemovedDirect ?? toSafeNumber(gitMetrics?.linesDeleted) ?? toSafeNumber(worktreeSummary?.deletions) ?? 0;
+  if (filesChanged <= 0 && linesAdded <= 0 && linesRemoved <= 0) {
+    return null;
+  }
+  return { filesChanged, linesAdded, linesRemoved };
+}
+function formatVariantTestVerificationLine(candidateRecord) {
+  const record = candidateRecord;
+  const signals = [
+    record.outcome?.verification?.testStatus,
+    record.testStatus,
+    record.testsExecuted?.exitCode,
+    record.testMetrics?.failedTests
+  ];
+  if (signals.every((signal) => signal == null)) return null;
+  const gate = readVariantVerification(candidateRecord).gates.test;
+  const reason = gate.unavailableReason ? ` (${gate.unavailableReason})` : "";
+  return `Tests: ${gate.status}${reason}`;
+}
+function compareVariantLabels(a, b) {
+  const vLabelA = a.match(/^v(\d+)$/i);
+  const vLabelB = b.match(/^v(\d+)$/i);
+  if (vLabelA && vLabelB) {
+    return Number(vLabelA[1]) - Number(vLabelB[1]);
+  }
+  if (vLabelA) return -1;
+  if (vLabelB) return 1;
+  const variantLabelA = a.match(/^variant-(\d+)$/i);
+  const variantLabelB = b.match(/^variant-(\d+)$/i);
+  if (variantLabelA && variantLabelB) {
+    return Number(variantLabelA[1]) - Number(variantLabelB[1]);
+  }
+  if (variantLabelA) return -1;
+  if (variantLabelB) return 1;
+  return a.localeCompare(b);
+}
+function variantIdentityCandidates(variant) {
+  const provider = variant.provider;
+  const executionMode = variant.executionMode;
+  const model = variant.model;
+  const resolvedModel = variant.resolvedModel;
+  const models = resolvedModel && resolvedModel !== model ? [resolvedModel, model] : [model];
+  const strategy = variant.strategy;
+  return [
+    variant.variant ?? null,
+    provider,
+    ...models.flatMap(
+      (m) => m ? [`${provider}:${m}`, executionMode ? `${provider}:${m}:${executionMode}` : null] : []
+    ),
+    `${provider}:${strategy}`,
+    executionMode ? `${provider}:${strategy}:${executionMode}` : null,
+    ...models.flatMap(
+      (m) => m ? [
+        `${provider}:${m}:${strategy}`,
+        executionMode ? `${provider}:${m}:${strategy}:${executionMode}` : null
+      ] : []
+    )
+  ].filter((value) => Boolean(value));
+}
+function findVariantInputSpecWarning(variantIds, variants) {
+  const normalizedIds = new Set(
+    variantIds.filter((value) => typeof value === "string").map((value) => value.trim()).filter(Boolean)
+  );
+  if (normalizedIds.size === 0) return null;
+  for (const variant of variants) {
+    if (!variant.inputSpecWarning) continue;
+    if (variantIdentityCandidates(variant).some((identity) => normalizedIds.has(identity))) {
+      return variant.inputSpecWarning;
+    }
+  }
+  return null;
+}
+function extractVariantLabelMapping(evaluation) {
+  const mapping = {};
+  const directMapping = typeof evaluation.variantLabelMapping === "object" && evaluation.variantLabelMapping !== null ? evaluation.variantLabelMapping : null;
+  if (directMapping) {
+    for (const [label, variant] of Object.entries(directMapping)) {
+      if (typeof variant !== "string") continue;
+      const trimmedLabel = label.trim();
+      const trimmedVariant = variant.trim();
+      if (trimmedLabel.length === 0 || trimmedVariant.length === 0) continue;
+      mapping[trimmedLabel] = trimmedVariant;
+    }
+  }
+  const variantScores = typeof evaluation.variantScores === "object" && evaluation.variantScores !== null ? evaluation.variantScores : null;
+  const pointerMapping = typeof variantScores?.variantLabelMapping === "object" && variantScores.variantLabelMapping !== null ? variantScores.variantLabelMapping : null;
+  if (pointerMapping) {
+    for (const [label, variant] of Object.entries(pointerMapping)) {
+      if (typeof variant !== "string") continue;
+      const trimmedLabel = label.trim();
+      const trimmedVariant = variant.trim();
+      if (trimmedLabel.length === 0 || trimmedVariant.length === 0) continue;
+      mapping[trimmedLabel] = trimmedVariant;
+    }
+  }
+  if (variantScores) {
+    for (const [variant, data] of Object.entries(variantScores)) {
+      const payload = data;
+      if (!payload || typeof payload !== "object") continue;
+      if (typeof payload.label !== "string") continue;
+      const trimmedLabel = payload.label.trim();
+      if (trimmedLabel.length === 0) continue;
+      mapping[trimmedLabel] = variant;
+    }
+  }
+  return Object.entries(mapping).map(([label, variant]) => ({ label, variant })).sort((a, b) => compareVariantLabels(a.label, b.label));
+}
+function formatStoredJudgeType(judgeType) {
+  switch (judgeType) {
+    case "ai":
+      return "AI";
+    case "multi-agent":
+      return "Multi-Agent";
+    case "multi-lens":
+      return "Multi-Lens";
+    case "canonical":
+      return "Canonical";
+    case "consolidated":
+      return "Consolidated";
+    case "unknown":
+      return "Unknown";
+  }
+}
+function judgeTypeDisplayPriority(judgeType) {
+  switch (judgeType) {
+    case "ai":
+      return 0;
+    case "multi-agent":
+      return 1;
+    case "multi-lens":
+      return 2;
+    case "canonical":
+      return 3;
+    case "consolidated":
+      return 4;
+    case "unknown":
+      return 5;
+  }
+}
+function normalizeDisplayJudgeEvaluations(entries) {
+  const preferred = entries.filter(
+    (entry) => entry.judgeType === "ai" || entry.judgeType === "multi-agent" || entry.judgeType === "multi-lens"
+  );
+  const source = preferred.length > 0 ? preferred : entries;
+  return [...source].sort((a, b) => {
+    const priorityDelta = judgeTypeDisplayPriority(a.judgeType) - judgeTypeDisplayPriority(b.judgeType);
+    if (priorityDelta !== 0) return priorityDelta;
+    return a.evaluationId.localeCompare(b.evaluationId);
+  });
+}
+function getVariantOverallScore(entry) {
+  if (!entry || typeof entry !== "object") return null;
+  if (typeof entry.rankingScore === "number" && Number.isFinite(entry.rankingScore)) {
+    return entry.rankingScore;
+  }
+  if (typeof entry.compositeScore === "number" && Number.isFinite(entry.compositeScore)) {
+    return entry.compositeScore;
+  }
+  if (typeof entry.overallScore === "number" && Number.isFinite(entry.overallScore)) {
+    return entry.overallScore;
+  }
+  return null;
+}
+function buildPerJudgeVariantMatrix(entries) {
+  const matrix = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const judgeLabel = formatStoredJudgeType(entry.judgeType);
+    for (const [variant, payload] of Object.entries(entry.variantScores ?? {})) {
+      if (!payload || typeof payload !== "object" || !("scores" in payload)) {
+        continue;
+      }
+      const variantEntry = matrix.get(variant) ?? {
+        labels: /* @__PURE__ */ new Set(),
+        scoresByJudge: {}
+      };
+      if (typeof payload?.label === "string" && payload.label.trim().length > 0) {
+        variantEntry.labels.add(payload.label.trim());
+      }
+      variantEntry.scoresByJudge[judgeLabel] = getVariantOverallScore(payload);
+      matrix.set(variant, variantEntry);
+    }
+  }
+  return [...matrix.entries()].map(([variant, value]) => ({
+    variant,
+    labels: [...value.labels].sort(compareVariantLabels),
+    scoresByJudge: value.scoresByJudge
+  })).sort((a, b) => a.variant.localeCompare(b.variant));
+}
+function renderPerJudgeVariantScores(entries) {
+  const displayEntries = normalizeDisplayJudgeEvaluations(entries);
+  if (displayEntries.length < 2) return;
+  const judgeLabels = displayEntries.map((entry) => formatStoredJudgeType(entry.judgeType));
+  const matrix = buildPerJudgeVariantMatrix(displayEntries);
+  if (matrix.length === 0) return;
+  console.log(chalk6.cyan.bold("Per-Judge Variant Scores:\n"));
+  for (const entry of displayEntries) {
+    const winnerBits = [formatStoredJudgeType(entry.judgeType)];
+    if (entry.winnerVariant) {
+      const scoreSuffix = typeof entry.winnerScore === "number" ? ` (${entry.winnerScore.toFixed(1)})` : "";
+      winnerBits.push(`winner=${entry.winnerVariant}${scoreSuffix}`);
+    }
+    if (entry.workerPacketArtifactPath) {
+      winnerBits.push(`workerPackets=${entry.workerPacketArtifactPath}`);
+    }
+    console.log(chalk6.gray(`  ${winnerBits.join(" \u2022 ")}`));
+  }
+  console.log();
+  for (const row of matrix) {
+    const labelText = row.labels.length > 0 ? ` [${row.labels.join(", ")}]` : "";
+    console.log(chalk6.white(`  ${row.variant}${labelText}`));
+    for (const judgeLabel of judgeLabels) {
+      const score = row.scoresByJudge[judgeLabel];
+      const scoreText = typeof score === "number" ? score.toFixed(1) : "n/a";
+      console.log(chalk6.gray(`    ${judgeLabel}: ${scoreText}`));
+    }
+  }
+  console.log();
+}
+function formatDonorDecisionDiagnostics(decisions) {
+  if (!Array.isArray(decisions)) return [];
+  return decisions.map((entry) => {
+    if (typeof entry !== "object" || entry === null) return null;
+    const decision = entry;
+    if (typeof decision.variant !== "string") return null;
+    const variant = decision.variant;
+    if (decision.winner) {
+      const scorePart = typeof decision.selectedJudgeScore === "number" ? `, score ${decision.selectedJudgeScore}` : "";
+      return `+ ${variant} (winner${scorePart})`;
+    }
+    if (decision.selected) {
+      const parts = ["donor"];
+      if (typeof decision.selectedJudgeRank === "number") {
+        parts.push(`rank ${decision.selectedJudgeRank}`);
+      }
+      if (typeof decision.selectedJudgeScore === "number") {
+        parts.push(`score ${decision.selectedJudgeScore}`);
+      }
+      const reasons2 = Array.isArray(decision.reasons) ? decision.reasons.filter((r) => typeof r === "string") : [];
+      const selectionReason = reasons2.find(
+        (r) => r.startsWith("selected") || r.includes("semantic donor")
+      );
+      if (selectionReason) {
+        parts.push(
+          selectionReason.includes("semantic donor rejected") ? selectionReason.replace("semantic donor rejected:", "semantic profile note:") : selectionReason
+        );
+      }
+      return `+ ${variant} (${parts.join(", ")})`;
+    }
+    const reasons = Array.isArray(decision.reasons) ? decision.reasons.filter((r) => typeof r === "string") : [];
+    const primaryReason = reasons.find((r) => !r.startsWith("not selected")) ?? reasons[0] ?? "not selected";
+    return `- ${variant} (${primaryReason})`;
+  }).filter((line) => line !== null);
+}
+function summarizeDonorSelectionDecisions(decisions) {
+  if (!Array.isArray(decisions)) return [];
+  return decisions.map((entry) => {
+    if (typeof entry !== "object" || entry === null) return null;
+    const decision = entry;
+    if (typeof decision.variant !== "string") return null;
+    const reasons = Array.isArray(decision.reasons) ? decision.reasons.filter((reason) => typeof reason === "string") : [];
+    const status = decision.winner ? "declared winner" : decision.selected ? "selected" : "not selected";
+    const shown = decision.selected ? reasons.map(
+      (reason) => reason.replace("semantic donor rejected:", "semantic profile note:")
+    ) : reasons;
+    const details = shown.length > 0 ? `: ${shown.join("; ")}` : "";
+    return `${decision.variant} (${status})${details}`;
+  }).filter((line) => line !== null && line.length > 0);
+}
+function summarizeSynthesisArtifact(artifact) {
+  if (!artifact) return null;
+  const synthesisApplied = typeof artifact.synthesisApplied === "boolean" ? artifact.synthesisApplied : null;
+  const winnerFallback = typeof artifact.winnerFallback === "boolean" ? artifact.winnerFallback : null;
+  const synthesisOutcomeStatus = typeof artifact.synthesisOutcomeStatus === "string" ? artifact.synthesisOutcomeStatus : null;
+  const mergedVariants = Array.isArray(artifact.mergedVariants) ? artifact.mergedVariants.filter((value) => typeof value === "string").map(normalizeDisplayedVariantId) : [];
+  const contributingVariants = Array.isArray(artifact.contributingVariants) ? artifact.contributingVariants.filter((value) => typeof value === "string").map(normalizeDisplayedVariantId) : [];
+  const donorSelectionDecisions = Array.isArray(artifact.donorSelectionDecisions) ? artifact.donorSelectionDecisions : null;
+  const synthesisGateResults = readSynthesisGateResultSnapshot(artifact);
+  const harvestSummary = readHarvestManifestSummary(artifact.harvestManifest);
+  const normalizedWinnerOnlyAttribution = normalizeWinnerOnlyAttribution({
+    synthesisApplied,
+    winnerFallback,
+    mergedVariants,
+    contributingVariants,
+    donorSelectionDecisions,
+    declaredWinner: typeof artifact.declaredWinner === "object" && artifact.declaredWinner !== null ? artifact.declaredWinner : null
+  });
+  return {
+    strategy: typeof artifact.synthesisStrategy === "string" ? artifact.synthesisStrategy : null,
+    provider: typeof artifact.synthesisProvider === "string" ? artifact.synthesisProvider : null,
+    model: typeof artifact.synthesisModel === "string" ? artifact.synthesisModel : null,
+    reasoningEffort: typeof artifact.synthesisReasoningEffort === "string" ? artifact.synthesisReasoningEffort : null,
+    providerDurationMs: typeof artifact.synthesisProviderDurationMs === "number" ? artifact.synthesisProviderDurationMs : null,
+    gateDurationMs: typeof artifact.synthesisGateDurationMs === "number" ? artifact.synthesisGateDurationMs : null,
+    success: resolveSynthesisDeliveryProjection(artifact).success ? true : typeof artifact.success === "boolean" ? artifact.success : null,
+    resultStatus: resolveSynthesisDeliveryProjection(artifact).resultStatus,
+    deliverySucceeded: typeof artifact.deliverySucceeded === "boolean" ? artifact.deliverySucceeded : null,
+    synthesisApplied,
+    synthesisOutcomeStatus,
+    winnerFallback,
+    fallbackReason: typeof artifact.fallbackReason === "string" ? artifact.fallbackReason : null,
+    patchApplyValidated: typeof artifact.patchApplyValidated === "boolean" ? artifact.patchApplyValidated : null,
+    gatesPassed: typeof artifact.gatesPassed === "boolean" ? artifact.gatesPassed : null,
+    gateFailureDetails: typeof artifact.gateFailureDetails === "object" && artifact.gateFailureDetails !== null ? artifact.gateFailureDetails : null,
+    winnerClone: typeof artifact.winnerClone === "boolean" ? artifact.winnerClone : null,
+    noveltyScore: typeof artifact.noveltyScore === "number" ? artifact.noveltyScore : null,
+    mergedVariants: normalizedWinnerOnlyAttribution.mergedVariants,
+    contributingVariants: normalizedWinnerOnlyAttribution.contributingVariants,
+    donorSelectionDecisions,
+    reasoning: typeof artifact.reasoning === "string" ? artifact.reasoning : null,
+    error: typeof artifact.error === "string" ? artifact.error : null,
+    intentFilteredHunkCount: typeof artifact.intentFilteredHunkCount === "number" ? artifact.intentFilteredHunkCount : null,
+    excludedHunkCount: typeof artifact.excludedHunkCount === "number" ? artifact.excludedHunkCount : null,
+    unknownIncludedHunkCount: typeof artifact.unknownIncludedHunkCount === "number" ? artifact.unknownIncludedHunkCount : null,
+    unknownExcludedHunkCount: typeof artifact.unknownExcludedHunkCount === "number" ? artifact.unknownExcludedHunkCount : null,
+    overlapRejectedHunkCount: typeof artifact.overlapRejectedHunkCount === "number" ? artifact.overlapRejectedHunkCount : null,
+    complementaryPatchApplied: typeof artifact.complementaryPatchApplied === "boolean" ? artifact.complementaryPatchApplied : null,
+    applyMode: typeof artifact.applyMode === "string" ? artifact.applyMode : null,
+    aiGuidedFallbackAttempted: typeof artifact.aiGuidedFallbackAttempted === "boolean" ? artifact.aiGuidedFallbackAttempted : null,
+    aiGuidedFallbackOutcome: normalizeAiGuidedFallbackOutcome({
+      synthesisApplied,
+      winnerFallback,
+      outcome: typeof artifact.aiGuidedFallbackOutcome === "string" ? artifact.aiGuidedFallbackOutcome : null
+    }),
+    synthesisGateResults,
+    donorHunksAccepted: harvestSummary?.acceptedHunkCount ?? null,
+    donorHunksRejected: harvestSummary?.rejectedHunkCount ?? null,
+    donorHunksConsidered: harvestSummary?.consideredHunkCount ?? null
+  };
+}
+function readHarvestManifestSummary(value) {
+  if (!value || typeof value !== "object") return null;
+  const summary = value.summary;
+  if (!summary || typeof summary !== "object") return null;
+  const record = summary;
+  if (typeof record.acceptedHunkCount !== "number" || typeof record.rejectedHunkCount !== "number" || typeof record.consideredHunkCount !== "number") {
+    return null;
+  }
+  return {
+    acceptedHunkCount: record.acceptedHunkCount,
+    rejectedHunkCount: record.rejectedHunkCount,
+    consideredHunkCount: record.consideredHunkCount
+  };
+}
+function readSynthesisGateResultSnapshot(artifact) {
+  const raw = isRecord(artifact.synthesisGateResults) ? artifact.synthesisGateResults : isRecord(artifact.gateResults) ? artifact.gateResults : null;
+  if (!raw) return null;
+  return isSynthesisGateResultSnapshot(raw) ? raw : null;
+}
+function isSynthesisGateResultSnapshot(value) {
+  return typeof value.isEligible === "boolean" && typeof value.buildPassed === "boolean" && typeof value.lintPassed === "boolean" && typeof value.formatPassed === "boolean" && typeof value.buildStatus === "string" && typeof value.lintStatus === "string" && typeof value.testStatus === "string" && typeof value.formatStatus === "string";
+}
+function normalizeAiGuidedFallbackOutcome(params) {
+  if (params.synthesisApplied === false && params.winnerFallback === true && params.outcome === "donor_augmented") {
+    return "winner_equivalent";
+  }
+  return params.outcome;
+}
+function normalizeWinnerOnlyAttribution(params) {
+  const { synthesisApplied, winnerFallback } = params;
+  if (!(synthesisApplied === false && winnerFallback === true)) {
+    return {
+      mergedVariants: params.mergedVariants,
+      contributingVariants: params.contributingVariants
+    };
+  }
+  const winnerFromDecisions = params.donorSelectionDecisions?.map((entry) => {
+    if (typeof entry !== "object" || entry === null) return null;
+    const decision = entry;
+    if (decision.winner !== true || typeof decision.variant !== "string") return null;
+    return normalizeDisplayedVariantId(decision.variant.trim());
+  }).find((value) => Boolean(value));
+  const declaredWinnerProvider = typeof params.declaredWinner?.provider === "string" ? params.declaredWinner.provider.trim() : "";
+  const declaredWinnerVariant = typeof params.declaredWinner?.variant === "string" ? params.declaredWinner.variant.trim() : "";
+  const winnerFromDeclaredWinner = declaredWinnerProvider && declaredWinnerVariant ? normalizeDisplayedVariantId(
+    declaredWinnerVariant.startsWith(`${declaredWinnerProvider}:`) ? declaredWinnerVariant : `${declaredWinnerProvider}:${declaredWinnerVariant}`
+  ) : null;
+  const normalizedWinner = winnerFromDecisions ?? winnerFromDeclaredWinner ?? params.contributingVariants[0] ?? params.mergedVariants[0] ?? null;
+  if (!normalizedWinner) {
+    return {
+      mergedVariants: params.mergedVariants,
+      contributingVariants: params.contributingVariants
+    };
+  }
+  return {
+    mergedVariants: [normalizedWinner],
+    contributingVariants: [normalizedWinner]
+  };
+}
+function normalizeDisplayedVariantId(variantId) {
+  return repairDuplicatedProviderSegment(variantId);
+}
+function formatAiGuidedFallbackOutcomeLabel(attempted, outcome) {
+  if (attempted !== true) return null;
+  switch (outcome) {
+    case "donor_augmented":
+      return "agentic fallback donor-augmented (applied)";
+    case "winner_equivalent":
+      return "agentic fallback winner-equivalent (not applied)";
+    case "candidate_rejected":
+      return "agentic fallback candidate rejected by apply/gates (not applied)";
+    case "generation_failed":
+      return "agentic fallback generation failed (winner retained)";
+    default:
+      return "agentic fallback attempted";
+  }
+}
+function formatSynthesisTelemetrySummaryLines(synthesisArtifact, rawArtifact) {
+  const lines = [];
+  if (synthesisArtifact.strategy) {
+    lines.push(`  Strategy: ${synthesisArtifact.strategy}`);
+  }
+  if (synthesisArtifact.provider) {
+    lines.push(`  Provider: ${synthesisArtifact.provider}`);
+  }
+  if (synthesisArtifact.model) {
+    lines.push(`  Model: ${synthesisArtifact.model}`);
+  }
+  if (synthesisArtifact.reasoningEffort) {
+    lines.push(`  Reasoning Effort: ${synthesisArtifact.reasoningEffort}`);
+  }
+  if (typeof synthesisArtifact.providerDurationMs === "number") {
+    lines.push(`  Provider Duration: ${formatDurationMs(synthesisArtifact.providerDurationMs)}`);
+  }
+  if (typeof synthesisArtifact.gateDurationMs === "number") {
+    lines.push(`  Gate Duration: ${formatDurationMs(synthesisArtifact.gateDurationMs)}`);
+  }
+  const delivery = resolveSynthesisDeliveryProjection(synthesisArtifact);
+  if (delivery.success) {
+    lines.push("  Success: yes");
+  } else if (typeof synthesisArtifact.success === "boolean") {
+    lines.push(`  Success: ${synthesisArtifact.success ? "yes" : "no"}`);
+  }
+  if (delivery.resultStatus) {
+    lines.push(`  Result Status: ${delivery.resultStatus}`);
+  }
+  if (typeof synthesisArtifact.deliverySucceeded === "boolean") {
+    lines.push(`  Delivery Succeeded: ${synthesisArtifact.deliverySucceeded ? "yes" : "no"}`);
+  }
+  if (typeof synthesisArtifact.synthesisApplied === "boolean") {
+    lines.push(`  Synthesis Applied: ${synthesisArtifact.synthesisApplied ? "yes" : "no"}`);
+  }
+  if (synthesisArtifact.synthesisOutcomeStatus) {
+    lines.push(`  Synthesis Outcome: ${synthesisArtifact.synthesisOutcomeStatus}`);
+  }
+  if (typeof synthesisArtifact.winnerFallback === "boolean") {
+    lines.push(`  Winner Fallback: ${synthesisArtifact.winnerFallback ? "yes" : "no"}`);
+  }
+  if (typeof synthesisArtifact.patchApplyValidated === "boolean") {
+    lines.push(`  Patch Apply Validated: ${synthesisArtifact.patchApplyValidated ? "yes" : "no"}`);
+  }
+  if (typeof synthesisArtifact.gatesPassed === "boolean") {
+    lines.push(`  Gates Passed: ${synthesisArtifact.gatesPassed ? "yes" : "no"}`);
+  }
+  for (const line of formatSynthesisGateResultsSummaryLines(synthesisArtifact)) {
+    lines.push(line);
+  }
+  const gateFailureSummary = formatGateFailureDetailsSummary(synthesisArtifact.gateFailureDetails);
+  if (gateFailureSummary) {
+    lines.push(`  Gate Failure: ${gateFailureSummary}`);
+  }
+  if (synthesisArtifact.fallbackReason) {
+    lines.push(`  Fallback Reason: ${synthesisArtifact.fallbackReason}`);
+  }
+  if (typeof synthesisArtifact.winnerClone === "boolean") {
+    lines.push(`  Winner Clone: ${synthesisArtifact.winnerClone ? "yes" : "no"}`);
+  }
+  const aiFallbackLine = formatAiGuidedFallbackOutcomeLabel(
+    synthesisArtifact.aiGuidedFallbackAttempted,
+    synthesisArtifact.aiGuidedFallbackOutcome
+  );
+  if (aiFallbackLine) {
+    lines.push(`  AI Fallback: ${aiFallbackLine}`);
+  }
+  const donorMaterialLine = formatDonorMaterialSummaryLine(synthesisArtifact);
+  if (donorMaterialLine) {
+    lines.push(`  Donor Material: ${donorMaterialLine}`);
+  }
+  const synthesisValue = deriveSynthesisValueFromArtifactOrSummary(rawArtifact, synthesisArtifact);
+  if (synthesisValue) {
+    lines.push(`  Synthesis Value: ${formatSynthesisValueRunSummaryLine(synthesisValue)}`);
+  }
+  if (synthesisArtifact.applyMode) {
+    lines.push(`  Apply Mode: ${synthesisArtifact.applyMode}`);
+  }
+  const donorDiagnosticLines = formatDonorDecisionDiagnostics(
+    synthesisArtifact.donorSelectionDecisions
+  );
+  if (donorDiagnosticLines.length > 0) {
+    lines.push("  Donor Selection:");
+    for (const line of donorDiagnosticLines) {
+      lines.push(`    ${line}`);
+    }
+  }
+  return lines;
+}
+function formatCoverageLabel(status) {
+  switch (status) {
+    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 formatGateSummaryPart(input) {
+  const reason = input.reason?.trim().replace(/\s+/g, " ");
+  const suffix = reason ? `, ${reason}` : "";
+  return `${input.label}=${input.status ?? "not_run"} (${formatCoverageLabel(
+    input.coverageStatus
+  )}${suffix})`;
+}
+function formatSynthesisGateResultsSummaryLines(synthesisArtifact) {
+  if (synthesisArtifact.winnerFallback === true || synthesisArtifact.synthesisOutcomeStatus === "winner_carry_forward") {
+    return ["  Gate Source: carried-forward winner gates"];
+  }
+  const snapshot = synthesisArtifact.synthesisGateResults;
+  if (!snapshot) {
+    const status = synthesisArtifact.synthesisOutcomeStatus ?? "not_attempted";
+    return [`  Gate Results: not run (${status})`];
+  }
+  return [
+    "  Gate Source: synthesis worktree",
+    `  Gate Results: ${[
+      formatGateSummaryPart({
+        label: "build/typecheck",
+        status: snapshot.buildStatus,
+        coverageStatus: snapshot.buildCoverage?.status,
+        reason: snapshot.buildCoverage?.reason
+      }),
+      formatGateSummaryPart({
+        label: "lint",
+        status: snapshot.lintStatus,
+        coverageStatus: snapshot.lintCoverage?.status,
+        reason: snapshot.lintCoverage?.reason
+      }),
+      formatGateSummaryPart({
+        label: "test",
+        status: snapshot.testStatus,
+        coverageStatus: snapshot.testCoverage?.status,
+        reason: snapshot.testCoverage?.reason
+      }),
+      formatGateSummaryPart({
+        label: "format",
+        status: snapshot.formatPassed ? "passed" : snapshot.formatStatus === "verified" ? "failed" : "not_run",
+        coverageStatus: snapshot.formatCoverage?.status ?? snapshot.formatStatus,
+        reason: snapshot.formatCoverage?.reason
+      })
+    ].join("; ")}`
+  ];
+}
+function formatDurationMs(durationMs) {
+  if (!Number.isFinite(durationMs) || durationMs < 0) return "unknown";
+  if (durationMs < 1e3) return `${Math.round(durationMs)}ms`;
+  if (durationMs < 6e4) return `${(durationMs / 1e3).toFixed(1)}s`;
+  return `${(durationMs / 6e4).toFixed(1)}m`;
+}
+function formatDonorMaterialSummaryLine(artifact) {
+  const matched = artifact.intentFilteredHunkCount;
+  const excluded = artifact.excludedHunkCount;
+  const unknown = artifact.unknownIncludedHunkCount;
+  const unknownExcluded = artifact.unknownExcludedHunkCount;
+  const overlapRejected = artifact.overlapRejectedHunkCount;
+  const applied = artifact.complementaryPatchApplied;
+  const synthesisApplied = artifact.synthesisApplied;
+  const hasFallbackSignal = artifact.winnerFallback === true || typeof artifact.fallbackReason === "string" || typeof artifact.applyMode === "string" || synthesisApplied === false;
+  const hasAnyCount = typeof matched === "number" || typeof excluded === "number" || typeof unknown === "number" || typeof unknownExcluded === "number" || typeof overlapRejected === "number";
+  if (!hasAnyCount) {
+    const thresholdMissCount = countSemanticThresholdMissDonors(
+      artifact.donorSelectionDecisions ?? null
+    );
+    if (thresholdMissCount > 0) {
+      return `semantic threshold miss (${thresholdMissCount} donor${thresholdMissCount === 1 ? "" : "s"} below threshold)`;
+    }
+    const aiFallbackLabel = formatAiGuidedFallbackOutcomeLabel(
+      artifact.aiGuidedFallbackAttempted ?? null,
+      artifact.aiGuidedFallbackOutcome ?? null
+    );
+    if (aiFallbackLabel) return aiFallbackLabel;
+    return null;
+  }
+  const matchedCount = matched ?? 0;
+  const excludedCount = excluded ?? 0;
+  if (matchedCount === 0 && excludedCount === 0) {
+    return "none (no donor material found)";
+  }
+  if (matchedCount === 0 && excludedCount > 0) {
+    return `rejected by intent filtering (${excludedCount} hunk${excludedCount === 1 ? "" : "s"} excluded)`;
+  }
+  const parts = [`${matchedCount} matched hunk${matchedCount === 1 ? "" : "s"}`];
+  if (excludedCount > 0) {
+    parts.push(`${excludedCount} excluded`);
+  }
+  if (typeof overlapRejected === "number" && overlapRejected > 0) {
+    parts.push(`${overlapRejected} overlap-rejected`);
+  }
+  if (typeof unknown === "number" && unknown > 0) {
+    parts.push(`${unknown} unknown-included`);
+  }
+  if (typeof unknownExcluded === "number" && unknownExcluded > 0) {
+    parts.push(`${unknownExcluded} unknown-excluded`);
+  }
+  const statusSuffix = typeof applied === "boolean" ? applied ? ", applied" : ", not applied" : synthesisApplied === true ? ", applied" : hasFallbackSignal ? ", attempted" : "";
+  return `${parts.join(", ")}${statusSuffix}`;
+}
+function countSemanticThresholdMissDonors(decisions) {
+  if (!Array.isArray(decisions)) return 0;
+  return decisions.filter((entry) => {
+    if (typeof entry !== "object" || entry === null) return false;
+    const decision = entry;
+    if (decision.winner || decision.selected) return false;
+    const reasons = Array.isArray(decision.reasons) ? decision.reasons.filter((reason) => typeof reason === "string") : [];
+    return reasons.some((reason) => isSemanticThresholdMissReason(reason));
+  }).length;
+}
+function isSemanticThresholdMissReason(reason) {
+  const normalized = reason.toLowerCase();
+  return normalized.includes("semantic donor rejected") && normalized.includes("threshold");
+}
+function formatGateFailureDetailsSummary(details) {
+  if (!details || typeof details !== "object" || Array.isArray(details)) return null;
+  const record = details;
+  const gate = typeof record.gate === "string" ? record.gate : "unknown gate";
+  const status = typeof record.status === "string" ? record.status : "failed";
+  const reason = typeof record.reason === "string" ? record.reason : null;
+  const deliveryPreserved = typeof record.deliveryPreserved === "boolean" ? record.deliveryPreserved ? "winner preserved" : "winner not preserved" : null;
+  return [gate, status, deliveryPreserved, reason].filter(Boolean).join("; ");
+}
+function renderSynthesisTelemetryHuman(synthesisArtifact, rawArtifact) {
+  console.log(chalk6.blue.bold("Synthesis Telemetry:\n"));
+  for (const line of formatSynthesisTelemetrySummaryLines(synthesisArtifact, rawArtifact)) {
+    console.log(chalk6.gray(line));
+  }
+  if (typeof synthesisArtifact.noveltyScore === "number") {
+    console.log(chalk6.gray(`  Novelty Score: ${synthesisArtifact.noveltyScore}`));
+  }
+  if (synthesisArtifact.mergedVariants.length > 0) {
+    console.log(chalk6.gray(`  Merged Variants: ${synthesisArtifact.mergedVariants.join(", ")}`));
+  }
+  if (synthesisArtifact.contributingVariants.length > 0) {
+    console.log(
+      chalk6.gray(`  Contributing Variants: ${synthesisArtifact.contributingVariants.join(", ")}`)
+    );
+  }
+  if (synthesisArtifact.reasoning) {
+    console.log(chalk6.gray(`  Reasoning: ${synthesisArtifact.reasoning}`));
+  }
+  const donorDecisionLines = summarizeDonorSelectionDecisions(
+    synthesisArtifact.donorSelectionDecisions
+  );
+  if (donorDecisionLines.length > 0) {
+    console.log(chalk6.gray("  Donor Decisions:"));
+    for (const line of donorDecisionLines) {
+      console.log(chalk6.gray(`    - ${line}`));
+    }
+  }
+  if (synthesisArtifact.error) {
+    console.log(chalk6.red(`  Error: ${synthesisArtifact.error}`));
+  }
+  console.log();
+}
+function buildSynthesisResultsJson(params) {
+  const generated = params.synthesisGenerated === true;
+  const aliases = {
+    attempted: Boolean(params.artifact) || Boolean(params.artifactParseWarning) || generated,
+    applied: params.artifact?.synthesisApplied ?? null,
+    artifactParseWarning: params.artifactParseWarning ?? null,
+    error: params.artifact?.error ?? null,
+    fallbackReason: params.artifact?.fallbackReason ?? null,
+    winnerFallback: params.artifact?.winnerFallback ?? null,
+    deliverySucceeded: params.artifact?.deliverySucceeded ?? null,
+    patchApplyValidated: params.artifact?.patchApplyValidated ?? null,
+    gatesPassed: params.artifact?.gatesPassed ?? null,
+    gateFailureDetails: params.artifact?.gateFailureDetails ?? null,
+    synthesisValue: deriveSynthesisValueFromArtifactOrSummary(params.rawArtifact, params.artifact)
+  };
+  return generated ? {
+    generated: true,
+    code: params.synthesisCode ?? null,
+    artifact: params.artifact,
+    ...aliases
+  } : {
+    generated: false,
+    code: null,
+    artifact: params.artifact,
+    ...aliases
+  };
+}
+function buildFusionSynthesisResultsJson(params) {
+  const analysisArtifact = params.analysisSynthesis ? {
+    kind: "analysis-synthesis",
+    status: params.analysisSynthesis.status ?? null,
+    markdownPath: params.analysisSynthesis.artifactPath ?? null,
+    jsonPath: params.analysisSynthesis.jsonPath ?? null,
+    contributorCount: params.analysisSynthesis.contributorCount ?? null
+  } : null;
+  const generated = params.synthesisGenerated === true || params.analysisSynthesis?.status === "succeeded";
+  const artifact = params.artifact ?? analysisArtifact;
+  return {
+    generated,
+    attempted: params.analysisSynthesis?.expected === true || Boolean(artifact) || Boolean(params.artifactParseWarning) || generated,
+    code: generated ? params.synthesisCode ?? null : null,
+    artifact,
+    artifactParseWarning: params.artifactParseWarning ?? null,
+    error: params.artifact?.error ?? (params.analysisSynthesis?.status === "failed" ? "Fusion synthesis failed" : null),
+    deliverySucceeded: params.artifact?.deliverySucceeded ?? (params.analysisSynthesis?.status === "succeeded" ? true : null)
+  };
+}
+function readSynthesisArtifact(taskId, telemetryDir) {
+  const artifactPath = path2.join(telemetryDir, "synthesis", `${taskId}.json`);
+  if (!fs.existsSync(artifactPath)) {
+    return { artifact: null, parseWarning: null };
+  }
+  try {
+    return {
+      artifact: parseJsonWithContext(
+        fs.readFileSync(artifactPath, "utf-8"),
+        `Synthesis artifact (${taskId})`
+      ),
+      parseWarning: null
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      artifact: null,
+      parseWarning: `${artifactPath}: ${message}`
+    };
+  }
+}
+function readFusionAnalysisSynthesisArtifact(taskId, buildDir) {
+  const readFromArtifactDir = (artifactDir) => {
+    const manifestPath = path2.join(artifactDir, `${taskId}.manifest.json`);
+    const legacyJsonPath = path2.join(artifactDir, `${taskId}.json`);
+    const jsonPath = fs.existsSync(manifestPath) ? manifestPath : legacyJsonPath;
+    const markdownPath = path2.join(artifactDir, `${taskId}.md`);
+    const hasJson = fs.existsSync(jsonPath);
+    const hasMarkdown = fs.existsSync(markdownPath);
+    if (!hasJson && !hasMarkdown) {
+      return null;
+    }
+    if (!hasJson) {
+      return {
+        jsonPath: null,
+        markdownPath: hasMarkdown ? markdownPath : null,
+        artifact: null,
+        parseWarning: null
+      };
+    }
+    try {
+      return {
+        jsonPath,
+        markdownPath: hasMarkdown ? markdownPath : null,
+        artifact: parseJsonWithContext(
+          fs.readFileSync(jsonPath, "utf-8"),
+          `Fusion analysis synthesis artifact (${taskId})`
+        ),
+        parseWarning: null
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        jsonPath,
+        markdownPath: hasMarkdown ? markdownPath : null,
+        artifact: null,
+        parseWarning: `${jsonPath}: ${message}`
+      };
+    }
+  };
+  const rootArtifact = readFromArtifactDir(path2.join(buildDir, "analysis-synthesis"));
+  if (rootArtifact) {
+    return rootArtifact;
+  }
+  const labsDir = resolveLabsRoot(buildDir);
+  if (!fs.existsSync(labsDir)) {
+    return null;
+  }
+  for (const labId of fs.readdirSync(labsDir).sort()) {
+    const runsDir = path2.join(labsDir, labId, "runs");
+    if (!fs.existsSync(runsDir)) {
+      continue;
+    }
+    for (const runId of fs.readdirSync(runsDir).sort()) {
+      const artifact = readFromArtifactDir(path2.join(runsDir, runId, "analysis-synthesis"));
+      if (artifact) {
+        return artifact;
+      }
+    }
+  }
+  return null;
+}
+function getRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function getArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function extractIntegratedContributorIdsFromTrust(artifact) {
+  if (artifact.kind === "fusion-synthesis-manifest" && Array.isArray(artifact.contributors)) {
+    return artifact.contributors.flatMap((entry) => {
+      const contributor = getRecord(entry);
+      const variantId = contributor?.variantId;
+      return contributor?.status === "included" && typeof variantId === "string" ? [normalizeDisplayedVariantId(variantId)] : [];
+    });
+  }
+  const trust = getRecord(artifact.trust);
+  const trustContributors = getRecord(trust?.contributors);
+  if (trustContributors) {
+    const statuses = trustContributors.statuses;
+    if (statuses && typeof statuses === "object" && !Array.isArray(statuses)) {
+      const ordered = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const [rawId, status] of Object.entries(statuses)) {
+        if (status !== "included") continue;
+        if (typeof rawId !== "string" || rawId.trim().length === 0) continue;
+        const id = normalizeDisplayedVariantId(rawId);
+        if (!id || seen.has(id)) continue;
+        seen.add(id);
+        ordered.push(id);
+      }
+      return ordered;
+    }
+    return [];
+  }
+  const inputs = getRecord(artifact.inputs);
+  const contributorHealth = inputs?.contributorHealth;
+  if (Array.isArray(contributorHealth)) {
+    const ordered = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const entry of contributorHealth) {
+      const record = getRecord(entry);
+      if (!record || record.status !== "included") continue;
+      const rawId = record.variantId;
+      if (typeof rawId !== "string" || rawId.trim().length === 0) continue;
+      const id = normalizeDisplayedVariantId(rawId);
+      if (!id || seen.has(id)) continue;
+      seen.add(id);
+      ordered.push(id);
+    }
+    return ordered;
+  }
+  return null;
+}
+function extractFusionContributorIdsFromAttributions(artifact) {
+  const contributors = /* @__PURE__ */ new Set();
+  const crossVariant = getRecord(artifact.crossVariant);
+  const sections = [
+    ...getArray(crossVariant?.consensus),
+    ...getArray(crossVariant?.contradictions),
+    ...getArray(crossVariant?.partialCoverage),
+    ...getArray(crossVariant?.uniqueInsights),
+    ...getArray(crossVariant?.blindSpots)
+  ];
+  for (const section of sections) {
+    const sectionRecord = getRecord(section);
+    for (const attribution of getArray(sectionRecord?.attributions)) {
+      const attributionRecord = getRecord(attribution);
+      const variantId = attributionRecord?.variantId;
+      if (typeof variantId === "string" && variantId.trim().length > 0) {
+        contributors.add(normalizeDisplayedVariantId(variantId));
+      }
+    }
+  }
+  return [...contributors];
+}
+function extractFusionContributorIds(artifact) {
+  if (!artifact) return [];
+  const fromTrust = extractIntegratedContributorIdsFromTrust(artifact);
+  if (fromTrust !== null) {
+    return fromTrust;
+  }
+  return extractFusionContributorIdsFromAttributions(artifact);
+}
+function buildFusionAnalysisSynthesisJson(params) {
+  const artifact = params.read.artifact;
+  const isV2Manifest = artifact?.kind === "fusion-synthesis-manifest";
+  const crossVariant = getRecord(artifact?.crossVariant);
+  const persistedAnswer = isV2Manifest && params.read.markdownPath && fs.existsSync(params.read.markdownPath) ? fs.readFileSync(params.read.markdownPath, "utf8").replace(/\n$/, "") : null;
+  const finalRecommendation = isV2Manifest ? persistedAnswer ? {
+    summary: persistedAnswer.split(/\r?\n/).map((line) => line.replace(/^#+\s*/, "").trim()).find((line) => line.length > 0) ?? "Fusion synthesis completed.",
+    recommendation: persistedAnswer,
+    rationale: [],
+    risks: [],
+    nextSteps: []
+  } : null : getRecord(artifact?.finalRecommendation);
+  const status = typeof artifact?.status === "string" ? artifact.status : null;
+  const contributors = extractFusionContributorIds(artifact);
+  const markdownPath = params.read.markdownPath ? formatAnalysisSynthesisArtifactPath(params.read.markdownPath) : null;
+  const jsonPath = params.read.jsonPath ? formatAnalysisSynthesisArtifactPath(params.read.jsonPath) : null;
+  const artifactParseWarning = params.read.parseWarning && params.read.jsonPath ? params.read.parseWarning.replace(params.read.jsonPath, jsonPath ?? params.read.jsonPath) : params.read.parseWarning;
+  return {
+    taskId: params.taskId,
+    requestedTaskId: params.requestedTaskId,
+    resolvedTaskId: params.taskId,
+    runSemantics: "fusion",
+    result: status === "succeeded" ? "success" : status,
+    executionHealth: status === "succeeded" ? "clean" : status === "failed" ? "failed" : "degraded",
+    synthesis: {
+      status,
+      markdownPath,
+      jsonPath,
+      artifactParseWarning,
+      consensusCount: getArray(crossVariant?.consensus).length,
+      contradictionCount: getArray(crossVariant?.contradictions).length,
+      partialCoverageCount: getArray(crossVariant?.partialCoverage).length,
+      uniqueInsightCount: getArray(crossVariant?.uniqueInsights).length,
+      blindSpotCount: getArray(crossVariant?.blindSpots).length,
+      contributorCount: contributors.length,
+      contributors,
+      finalRecommendation: finalRecommendation && Object.keys(finalRecommendation).length > 0 ? finalRecommendation : null
+    },
+    ...isV2Manifest ? {
+      analysisSynthesis: artifact,
+      fusionAnswer: persistedAnswer
+    } : artifact ? { analysisSynthesis: artifact } : {}
+  };
+}
+function buildFusionArtifactJsonFields(read) {
+  if (!read?.artifact) return {};
+  if (!isFusionManifestV2(read.artifact)) {
+    return { analysisSynthesis: read.artifact };
+  }
+  const fusionAnswer = read.markdownPath && fs.existsSync(read.markdownPath) ? fs.readFileSync(read.markdownPath, "utf8").replace(/\n$/, "") : null;
+  return {
+    // Retain the established manifest field and expose the primary answer separately.
+    analysisSynthesis: read.artifact,
+    fusionAnswer
+  };
+}
+function isAnalysisSynthesisResultShape(value) {
+  if (!isRecord(value)) return false;
+  if (typeof value.status !== "string") return false;
+  if (!isRecord(value.finalRecommendation)) return false;
+  if (typeof value.finalRecommendation.recommendation !== "string") return false;
+  if (typeof value.finalRecommendation.summary !== "string") return false;
+  if (!Array.isArray(value.finalRecommendation.rationale)) return false;
+  if (!Array.isArray(value.finalRecommendation.risks)) return false;
+  if (!Array.isArray(value.finalRecommendation.nextSteps)) return false;
+  if (!isRecord(value.crossVariant)) return false;
+  for (const key of [
+    "consensus",
+    "contradictions",
+    "partialCoverage",
+    "uniqueInsights",
+    "blindSpots"
+  ]) {
+    if (!Array.isArray(value.crossVariant[key])) return false;
+  }
+  if (!isRecord(value.inputs)) return false;
+  if (!Array.isArray(value.inputs.variants)) return false;
+  if (typeof value.inputs.selectedTopN !== "number") return false;
+  if (!isRecord(value.provenance)) return false;
+  return true;
+}
+function printFusionMarkdown(markdown) {
+  console.log(markdown.endsWith("\n") ? markdown.slice(0, -1) : markdown);
+}
+function isFusionManifestV2(value) {
+  return isRecord(value) && value.kind === "fusion-synthesis-manifest" && value.schemaVersion === 2 && typeof value.status === "string";
+}
+function formatFusionInputTruncationNotice(inputTruncation) {
+  if (!inputTruncation) return void 0;
+  const contributorDetails = getArray(inputTruncation.contributors).map((value) => getRecord(value)).filter((value) => value !== void 0).flatMap((value) => {
+    const variantId = typeof value.variantId === "string" ? value.variantId : void 0;
+    const originalChars = typeof value.originalChars === "number" ? value.originalChars : void 0;
+    const consumedChars = typeof value.consumedChars === "number" ? value.consumedChars : void 0;
+    return variantId && originalChars !== void 0 && consumedChars !== void 0 ? [`${variantId} ${originalChars}->${consumedChars} chars`] : [];
+  });
+  if (contributorDetails.length > 0) {
+    return `Host input truncation: ${contributorDetails.join("; ")}`;
+  }
+  const contributors = getArray(inputTruncation.affectedContributors).filter(
+    (value) => typeof value === "string"
+  );
+  if (contributors.length === 0) return void 0;
+  const limit = typeof inputTruncation.perContributorChars === "number" ? ` at ${inputTruncation.perContributorChars} chars each` : "";
+  return `Truncated contributor inputs${limit}: ${contributors.join(", ")}`;
+}
+function renderFusionManifestDetails(artifact) {
+  if (!isFusionManifestV2(artifact)) return false;
+  const provenance = getRecord(artifact.provenance);
+  const completion = getRecord(artifact.completion);
+  const answer = getRecord(artifact.answer);
+  const persistence = getRecord(artifact.persistence);
+  const reconciliation = getRecord(artifact.reconciliation);
+  const degradedReasons = getArray(artifact.degradedReasons).filter(
+    (reason) => typeof reason === "string"
+  );
+  const inputTruncation = getRecord(artifact.inputTruncation);
+  console.log(chalk6.blue("  Manifest: v2 (host-owned)"));
+  if (typeof provenance?.provider === "string") {
+    const model = typeof provenance.model === "string" ? ` / ${provenance.model}` : "";
+    console.log(chalk6.blue(`  Synthesizer: ${provenance.provider}${model}`));
+  }
+  if (completion) {
+    console.log(
+      chalk6.blue(
+        `  Completion: provider=${completion.providerCompleted === true ? "yes" : "no"}, terminal-output=${completion.terminalOutputPresent === true ? "yes" : "no"}, marker=${completion.completionMarkerObserved === true ? "yes" : "no"}, response-bound-exceeded=${completion.responseBoundExceeded === true ? "yes" : "no"}`
+      )
+    );
+  }
+  if (answer) {
+    const redaction = answer.secretRedactionApplied === true ? "applied" : "not applied";
+    const hash = typeof answer.sha256 === "string" ? `, sha256=${answer.sha256}` : "";
+    console.log(chalk6.blue(`  Answer integrity: secret redaction ${redaction}${hash}`));
+  }
+  if (typeof persistence?.status === "string") {
+    console.log(chalk6.blue(`  Persistence: ${persistence.status}`));
+  }
+  if (degradedReasons.length > 0) {
+    console.log(chalk6.yellow(`  Degraded reasons: ${degradedReasons.join(", ")}`));
+  }
+  const inputTruncationNotice = formatFusionInputTruncationNotice(inputTruncation);
+  if (inputTruncationNotice) {
+    console.log(chalk6.yellow(`  ${inputTruncationNotice}`));
+  }
+  if (typeof reconciliation?.jsonPath === "string") {
+    console.log(chalk6.blue(`  Reconciliation: ${reconciliation.jsonPath}`));
+  }
+  return true;
+}
+function tryRenderFusionReadHuman(read, options = {}) {
+  if (!read) return false;
+  if (!isFusionManifestV2(read.artifact)) {
+    return tryRenderFusionArtifactHuman(read.artifact, options);
+  }
+  if (options.inspect === true) return false;
+  if (read.artifact.status !== "succeeded" && read.artifact.status !== "degraded") return false;
+  if (!read.markdownPath || !fs.existsSync(read.markdownPath)) return false;
+  if (read.artifact.status === "degraded") {
+    const reasons = getArray(read.artifact.degradedReasons).filter(
+      (reason) => typeof reason === "string"
+    );
+    console.log(
+      `Warning: Fusion answer is degraded${reasons.length > 0 ? ` (${reasons.join(", ")})` : ""}.`
+    );
+  }
+  const inputTruncationNotice = formatFusionInputTruncationNotice(
+    getRecord(read.artifact.inputTruncation)
+  );
+  if (inputTruncationNotice) {
+    console.log(`Warning: ${inputTruncationNotice}.`);
+  }
+  printFusionMarkdown(fs.readFileSync(read.markdownPath, "utf8"));
+  return true;
+}
+function tryRenderFusionArtifactHuman(artifact, options = {}) {
+  if (!artifact) return false;
+  const inspect = options.inspect === true;
+  try {
+    if (isAnalysisSynthesisResultShape(artifact)) {
+      printFusionMarkdown(
+        renderAnalysisSynthesisMarkdown(artifact, {
+          runSemantics: "fusion",
+          inspect
+        })
+      );
+      return true;
+    }
+    if (!inspect && hasUsableFusionRecommendation(artifact)) {
+      const finalRecommendation = getRecord(artifact.finalRecommendation);
+      const recommendation = finalRecommendation?.recommendation;
+      if (typeof recommendation === "string" && recommendation.trim().length > 0) {
+        printFusionMarkdown(renderFusionDeliverableMarkdown(recommendation));
+        return true;
+      }
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+function renderFusionAnalysisSynthesisInspectHuman(params) {
+  const artifact = params.read.artifact;
+  if (tryRenderFusionArtifactHuman(artifact, { inspect: true })) {
+    if (params.read.parseWarning) {
+      console.log(chalk6.yellow(`Warning: ${params.read.parseWarning}`));
+    }
+    return;
+  }
+  const json = buildFusionAnalysisSynthesisJson(params);
+  const synthesis = json.synthesis;
+  console.log(chalk6.blue.bold("\nFusion Results:\n"));
+  console.log(chalk6.gray(`  Task ID: ${params.taskId}`));
+  if (params.requestedTaskId !== params.taskId) {
+    console.log(chalk6.gray(`  Requested ID: ${params.requestedTaskId}`));
+  }
+  if (synthesis.status) {
+    console.log(chalk6.gray(`  Status: ${synthesis.status}`));
+  }
+  if (synthesis.markdownPath) {
+    console.log(chalk6.gray(`  Synthesis: ${synthesis.markdownPath}`));
+  }
+  if (synthesis.jsonPath) {
+    console.log(chalk6.gray(`  Synthesis JSON: ${synthesis.jsonPath}`));
+  }
+  console.log(chalk6.gray(`  Contributors: ${synthesis.contributorCount}`));
+  if (synthesis.contributors.length > 0) {
+    console.log(chalk6.gray(`    ${synthesis.contributors.join(", ")}`));
+  }
+  const renderedManifest = artifact ? renderFusionManifestDetails(artifact) : false;
+  if (!renderedManifest) {
+    console.log(chalk6.gray(`  Consensus Items: ${synthesis.consensusCount}`));
+    console.log(chalk6.gray(`  Contradictions: ${synthesis.contradictionCount}`));
+  }
+  const recommendation = synthesis.finalRecommendation;
+  const summary = recommendation?.summary;
+  const action = recommendation?.recommendation;
+  if (typeof summary === "string" && summary.trim().length > 0) {
+    console.log(chalk6.gray(`  Summary: ${summary.trim()}`));
+  }
+  if (typeof action === "string" && action.trim().length > 0) {
+    console.log(chalk6.gray(`  Recommendation: ${action.trim()}`));
+  }
+  if (synthesis.artifactParseWarning) {
+    console.log(chalk6.yellow(`  Warning: ${synthesis.artifactParseWarning}`));
+  }
+  if (isFusionManifestV2(artifact)) {
+    const reconciliation = getRecord(artifact.reconciliation);
+    const reconciliationJsonPath = reconciliation?.jsonPath;
+    if (typeof reconciliationJsonPath === "string" && reconciliationJsonPath.length > 0) {
+      console.log(chalk6.gray(`  Reconciliation: ${reconciliationJsonPath}`));
+      const resolvedPath = path2.resolve(process.cwd(), reconciliationJsonPath);
+      if (fs.existsSync(resolvedPath)) {
+        try {
+          const reconciliationArtifact = parseJsonWithContext(
+            fs.readFileSync(resolvedPath, "utf8"),
+            `Fusion reconciliation artifact (${params.taskId})`
+          );
+          tryRenderFusionArtifactHuman(reconciliationArtifact, { inspect: true });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          console.log(chalk6.yellow(`  Warning: ${message}`));
+        }
+      }
+    }
+  }
+  console.log();
+}
+function renderFusionAnalysisSynthesisHuman(params) {
+  if (tryRenderFusionReadHuman(params.read, { inspect: params.inspect })) {
+    if (params.read.parseWarning && params.inspect) {
+      console.log(chalk6.yellow(`Warning: ${params.read.parseWarning}`));
+    }
+    return;
+  }
+  renderFusionAnalysisSynthesisInspectHuman(params);
+}
+function renderFusionAnalysisSynthesisDetails(params) {
+  if (!params.read) return;
+  const json = buildFusionAnalysisSynthesisJson({
+    taskId: params.taskId,
+    requestedTaskId: params.requestedTaskId,
+    read: params.read
+  });
+  const synthesis = json.synthesis;
+  if (synthesis.markdownPath) {
+    console.log(chalk6.blue(`  Synthesis file: ${synthesis.markdownPath}`));
+  }
+  if (synthesis.jsonPath) {
+    console.log(chalk6.blue(`  Synthesis JSON: ${synthesis.jsonPath}`));
+  }
+  if (params.read.artifact && renderFusionManifestDetails(params.read.artifact)) {
+    const recommendation2 = synthesis.finalRecommendation;
+    const summary2 = recommendation2?.summary;
+    if (typeof summary2 === "string" && summary2.trim().length > 0) {
+      console.log(chalk6.blue(`  Summary: ${summary2.trim()}`));
+    }
+    if (synthesis.artifactParseWarning) {
+      console.log(chalk6.yellow(`  Warning: ${synthesis.artifactParseWarning}`));
+    }
+    return;
+  }
+  console.log(chalk6.blue(`  Consensus Items: ${synthesis.consensusCount}`));
+  console.log(chalk6.blue(`  Contradictions: ${synthesis.contradictionCount}`));
+  console.log(chalk6.blue(`  Partial Coverage: ${synthesis.partialCoverageCount}`));
+  console.log(chalk6.blue(`  Unique Insights: ${synthesis.uniqueInsightCount}`));
+  console.log(chalk6.blue(`  Blind Spots: ${synthesis.blindSpotCount}`));
+  const recommendation = synthesis.finalRecommendation;
+  const summary = recommendation?.summary;
+  const action = recommendation?.recommendation;
+  if (typeof summary === "string" && summary.trim().length > 0) {
+    console.log(chalk6.blue(`  Summary: ${summary.trim()}`));
+  }
+  if (typeof action === "string" && action.trim().length > 0) {
+    console.log(chalk6.blue(`  Recommendation: ${action.trim()}`));
+  }
+  if (synthesis.artifactParseWarning) {
+    console.log(chalk6.yellow(`  Warning: ${synthesis.artifactParseWarning}`));
+  }
+}
+function createCompeteResultsCommand(options = {}) {
+  const surface = options.surface ?? "compete";
+  const isFusion = surface === "fusion";
+  const cmd = new Command("results");
+  cmd.description(
+    isFusion ? "View recorded Fusion synthesis results and execution health" : "View recorded competition results, winner details, and execution health"
+  ).argument(
+    isFusion ? "<task-id>" : "[task-id]",
+    isFusion ? "Fusion task ID" : "Competition task ID (defaults to the most recent competition)"
+  ).option("--warnings <level>", "Warning verbosity: silent|minimal|normal|verbose", "normal").option("--no-warnings", "Suppress all warnings (equivalent to --warnings silent)").option("--json", "Output results as JSON");
+  if (isFusion) {
+    cmd.option(
+      "--inspect",
+      "Show detailed Fusion reconciliation, trust, and provenance instead of the deliverable alone"
+    );
+    cmd.option(
+      "--verbose",
+      "Alias for --inspect: show detailed Fusion reconciliation, trust, and provenance"
+    );
+  }
+  cmd.addHelpText(
+    "after",
+    isFusion ? `
+Default human output prints the Fusion recommendation deliverable alone when present.
+Use --inspect or --verbose for the full reconciliation/provenance view. --json includes
+fusionAnswer plus analysisSynthesis when available and preserves synthesis summary fields.
+` : `
+JSON output includes:
+  - competitionResult: recorded run outcome
+  - executionHealth: clean, degraded, or failed execution state
+  - variants: provider outcomes and warning/input-spec metadata
+  - synthesis.artifactParseWarning: advisory parse warning when present
+`
+  ).action(async (taskId, options2, command) => {
+    options2 = reconcileRunNestedOptions(command, options2);
+    const inspectRequested = options2.inspect === true || options2.verbose === true;
+    const baseTelemetry = TelemetryLogger.getInstance();
+    let resolved;
+    try {
+      const requestedTaskId = taskId ?? await resolveDefaultCompetitionIdOrReport(resolveCliStateRoots().buildDir);
+      if (requestedTaskId === null) return;
+      const validatedTaskId = validateCommandOptions(TaskIdSchema, requestedTaskId);
+      let warningVerbosity = "normal";
+      if (options2.warnings === false) {
+        warningVerbosity = "silent";
+      } else if (typeof options2.warnings === "string") {
+        warningVerbosity = resolveWarningVerbosity(options2.warnings, "--warnings");
+      } else if (process.env.BUILD_WARNINGS) {
+        warningVerbosity = resolveWarningVerbosity(process.env.BUILD_WARNINGS, "BUILD_WARNINGS");
+      }
+      const warningFormatter = new WarningFormatter(warningVerbosity);
+      resolved = baseTelemetry.resolveLoggerForTaskWithLabFallback(validatedTaskId);
+      const telemetry = resolved.telemetry;
+      const evaluation = telemetry.variantsModule.getJudgeEvaluationDetails(validatedTaskId);
+      const judgeEvaluations = telemetry.variantsModule.listJudgeEvaluationDetails(validatedTaskId);
+      const roots = resolveCliStateRoots();
+      const buildDir = roots.buildDir;
+      const labResolver = LabPathResolver.getInstance();
+      const labBaseStateDir = resolved.usedLabFallback ? labResolver.getStateDir(buildDir) : void 0;
+      const telemetryDir = resolved.usedLabFallback ? labResolver.getTelemetryDir(buildDir) : telemetry.getTelemetryDir();
+      const stateReaderOpts = labBaseStateDir ? {
+        stateDir: path2.join(labBaseStateDir, "competitions"),
+        backgroundDir: path2.join(labBaseStateDir, "background"),
+        unifiedStateDir: labBaseStateDir
+      } : void 0;
+      const competitionStateCache = /* @__PURE__ */ new Map();
+      const labResolvedTaskIdByLookup = /* @__PURE__ */ new Map();
+      const labTelemetryDirByTaskId = /* @__PURE__ */ new Map();
+      const labAmbiguityByLookup = /* @__PURE__ */ new Map();
+      const getCompetitionState = (taskId2) => {
+        const cached = competitionStateCache.get(taskId2);
+        if (cached) return cached;
+        let state = readCompetitionState(taskId2, stateReaderOpts);
+        if (!hasCompetitionStateData(state)) {
+          let labMatch = null;
+          try {
+            labMatch = findLabRunStateForTask2(buildDir, taskId2);
+          } catch (error) {
+            if (error instanceof AmbiguousLabTaskIdError) {
+              labAmbiguityByLookup.set(taskId2, error);
+            } else {
+              throw error;
+            }
+          }
+          if (labMatch) {
+            state = readCompetitionState(
+              labMatch.taskId,
+              buildLabStateReaderOptions(labMatch.runRoot)
+            );
+            labResolvedTaskIdByLookup.set(taskId2, labMatch.taskId);
+            labTelemetryDirByTaskId.set(taskId2, path2.join(labMatch.runRoot, "telemetry"));
+            labTelemetryDirByTaskId.set(
+              labMatch.taskId,
+              path2.join(labMatch.runRoot, "telemetry")
+            );
+            competitionStateCache.set(labMatch.taskId, state);
+          }
+        }
+        competitionStateCache.set(taskId2, state);
+        return state;
+      };
+      let resolvedTaskId = resolveCompetitionResultsTaskId({
+        requestedTaskId: validatedTaskId,
+        evaluationTaskId: getStoredEvaluationTaskId(evaluation),
+        judgeEvaluationTaskIds: judgeEvaluations.map((entry) => getStoredEvaluationTaskId(entry)),
+        hasCompetitionState: (taskId2) => hasCompetitionStateData(getCompetitionState(taskId2))
+      });
+      resolvedTaskId = labResolvedTaskIdByLookup.get(resolvedTaskId) ?? resolvedTaskId;
+      const selectedLabAmbiguity = labAmbiguityByLookup.get(resolvedTaskId);
+      if (selectedLabAmbiguity) {
+        throw selectedLabAmbiguity;
+      }
+      const bypassedRequestedAmbiguity = resolvedTaskId !== validatedTaskId ? labAmbiguityByLookup.get(validatedTaskId) : void 0;
+      const compState = getCompetitionState(resolvedTaskId);
+      const resolvedTelemetryDir = labTelemetryDirByTaskId.get(resolvedTaskId) ?? telemetryDir;
+      const multiJudgeRun = getLatestMultiJudgeRunForTask(telemetry, resolvedTaskId);
+      const winnerFlipRow = getLatestWinnerFlipForTask(telemetry, resolvedTaskId);
+      const defaultTelemetryDir = roots.telemetryDir;
+      let synthesisArtifactRead = readSynthesisArtifact(resolvedTaskId, resolvedTelemetryDir);
+      if (synthesisArtifactRead.artifact === null && resolvedTelemetryDir !== defaultTelemetryDir) {
+        synthesisArtifactRead = readSynthesisArtifact(resolvedTaskId, defaultTelemetryDir);
+      }
+      const synthesisArtifact = summarizeSynthesisArtifact(
+        synthesisArtifactRead.artifact ?? compState.synthesis ?? null
+      );
+      const matrixSummary = readLatestProfileMatrixSummary({
+        evaluations: judgeEvaluations,
+        telemetryDirs: [
+          .../* @__PURE__ */ new Set([telemetry.getTelemetryDir(), resolvedTelemetryDir, defaultTelemetryDir])
+        ]
+      }) ?? matrixSummaryFromStateMetadata(compState.runMetadata?.matrix);
+      const isFusionResult = isFusion || compState.runMetadata?.runSemantics === "fusion";
+      const fusionAnalysisRead = isFusionResult ? readFusionAnalysisSynthesisArtifact(resolvedTaskId, buildDir) : null;
+      if (isFusionResult && !options2.json && fusionAnalysisRead?.artifact) {
+        if (!inspectRequested) {
+          renderFusionAnalysisSynthesisHuman({
+            taskId: resolvedTaskId,
+            requestedTaskId: validatedTaskId,
+            read: fusionAnalysisRead,
+            inspect: false
+          });
+          return;
+        }
+        if (evaluation) {
+          if (hasCompetitionStateData(compState)) {
+            const rawHandle = compState.rawHandle;
+            const rawCandidates = Array.isArray(rawHandle?.candidates) ? rawHandle.candidates : Array.isArray(rawHandle?.variants) ? rawHandle.variants : [];
+            const winnerReconciliation2 = buildWinnerReconciliationForResults({
+              evaluation: void 0,
+              compState,
+              winnerFlipRow,
+              multiJudgeRun
+            });
+            renderFallbackResults(
+              resolvedTaskId,
+              rawCandidates,
+              null,
+              null,
+              compState,
+              fusionAnalysisRead,
+              winnerReconciliation2.requiredGatePolicy,
+              {
+                inspect: true,
+                undeliveredLineFor: undeliveredLineLookup(
+                  telemetry.variantsModule,
+                  resolvedTaskId
+                )
+              }
+            );
+            return;
+          }
+          renderFusionAnalysisSynthesisHuman({
+            taskId: resolvedTaskId,
+            requestedTaskId: validatedTaskId,
+            read: fusionAnalysisRead,
+            inspect: true
+          });
+          return;
+        }
+      }
+      if (!evaluation) {
+        const fallbackState = compState;
+        if (!hasCompetitionStateData(fallbackState)) {
+          if (fusionAnalysisRead) {
+            if (options2.json) {
+              console.log(
+                JSON.stringify(
+                  buildFusionAnalysisSynthesisJson({
+                    taskId: resolvedTaskId,
+                    requestedTaskId: validatedTaskId,
+                    read: fusionAnalysisRead
+                  }),
+                  null,
+                  2
+                )
+              );
+            } else {
+              renderFusionAnalysisSynthesisHuman({
+                taskId: resolvedTaskId,
+                requestedTaskId: validatedTaskId,
+                read: fusionAnalysisRead,
+                inspect: inspectRequested
+              });
+            }
+            return;
+          }
+          if (options2.json) {
+            console.log(
+              JSON.stringify(
+                {
+                  error: "No evaluation found",
+                  taskId: resolvedTaskId,
+                  hints: buildNoEvaluationFoundHints(surface, resolvedTaskId)
+                },
+                null,
+                2
+              )
+            );
+          } else {
+            renderNoEvaluationFoundError(surface, resolvedTaskId);
+          }
+          process.exitCode = 1;
+          return;
+        }
+        if (options2.json) {
+          const rawCandidates2 = getRawCompetitionCandidates(fallbackState);
+          const isFusionFallback2 = surface === "fusion" || fallbackState.runMetadata?.runSemantics === "fusion";
+          const runMetadata = fallbackState.runMetadata ? {
+            ...fallbackState.runMetadata,
+            ...isFusionFallback2 ? { judge: void 0, replay: void 0 } : {}
+          } : null;
+          const outcome = isFusionFallback2 ? null : fallbackState.outcome ?? null;
+          const winnerReconciliation3 = buildWinnerReconciliationForResults({
+            evaluation: void 0,
+            compState: fallbackState,
+            winnerFlipRow,
+            multiJudgeRun
+          });
+          console.log(
+            JSON.stringify(
+              {
+                taskId: resolvedTaskId,
+                requestedTaskId: validatedTaskId,
+                resolvedTaskId,
+                executionMode: fallbackState.executionMode ?? null,
+                initiatedBy: fallbackState.initiatedBy ?? null,
+                outcome,
+                ...isFusionFallback2 ? {
+                  fusionResult: resolveCompetitionResultFromState(fallbackState),
+                  ...getFusionRunReadModel(resolvedTaskId, stateReaderOpts)
+                } : {
+                  competitionResult: resolveCompetitionResultFromState(fallbackState),
+                  judgeOperationsV1: projectJudgeOperationsFromState(
+                    { id: resolvedTaskId, kind: "compete" },
+                    fallbackState
+                  ),
+                  ...getCompetitionRunReadModel(resolvedTaskId, stateReaderOpts)
+                },
+                executionHealth: resolveExecutionHealthFromState(fallbackState),
+                runMetadata,
+                lab: fallbackState.labId || fallbackState.labRunId ? {
+                  labId: fallbackState.labId ?? null,
+                  runId: fallbackState.labRunId ?? null
+                } : null,
+                ...!isFusionFallback2 ? { judge: buildFallbackJudgeSummary(fallbackState) } : {},
+                decision: buildFallbackDecisionSummary(fallbackState),
+                ...!isFusionFallback2 ? {
+                  winner: fallbackState.outcome === "winner_selected" && fallbackState.winner ? {
+                    provider: fallbackState.winner.provider ?? null,
+                    model: fallbackState.winner.resolvedModel ?? fallbackState.winner.model ?? null,
+                    variant: fallbackState.winner.variant ?? null,
+                    provenance: fallbackState.decision?.decisionStatus === "declared" ? "competition_handle; persisted judge decision" : "competition_handle; judge evaluation telemetry unavailable"
+                  } : null,
+                  ungradedIdentity: fallbackState.decision?.reason === "judge_off" && fallbackState.winner ? {
+                    provider: fallbackState.winner.provider ?? null,
+                    model: fallbackState.winner.resolvedModel ?? fallbackState.winner.model ?? null,
+                    variant: fallbackState.winner.variant ?? null
+                  } : null
+                } : {},
+                candidates: rawCandidates2.map(
+                  (candidate) => buildCompetitionHandleVariantJson(candidate, {
+                    runSemantics: fallbackState.runMetadata?.runSemantics ?? null
+                  })
+                ),
+                variants: rawCandidates2.map(
+                  (candidate) => buildCompetitionHandleVariantJson(candidate, {
+                    runSemantics: fallbackState.runMetadata?.runSemantics ?? null
+                  })
+                ),
+                synthesis: isFusionFallback2 ? buildFusionSynthesisResultsJson({
+                  synthesisGenerated: false,
+                  artifact: synthesisArtifact,
+                  artifactParseWarning: synthesisArtifactRead.parseWarning,
+                  analysisSynthesis: fallbackState.runMetadata?.synthesis
+                }) : buildSynthesisResultsJson({
+                  synthesisGenerated: false,
+                  artifact: synthesisArtifact,
+                  artifactParseWarning: synthesisArtifactRead.parseWarning,
+                  rawArtifact: synthesisArtifactRead.artifact
+                }),
+                ...isFusionFallback2 ? buildFusionArtifactJsonFields(fusionAnalysisRead) : {},
+                ...!isFusionFallback2 ? {
+                  multiJudge: multiJudgeRun ?? null,
+                  matrix: matrixSummary,
+                  judgeEvaluations
+                } : {},
+                ...!isFusionFallback2 && winnerReconciliation3.hasTelemetry ? { winnerReconciliation: winnerReconciliation3 } : {}
+              },
+              null,
+              2
+            )
+          );
+          return;
+        }
+        if (resolved?.resolvedDbPath) {
+          const relativeDbPath = path2.relative(process.cwd(), resolved.resolvedDbPath);
+          const resolvedLabel = relativeDbPath.length > 0 && !relativeDbPath.startsWith("..") ? relativeDbPath : resolved.resolvedDbPath;
+          const suffix = resolved.usedLabFallback ? " (lab fallback)" : "";
+          console.log(chalk6.gray(`
+Telemetry DB: ${resolvedLabel}${suffix}
+`));
+        }
+        const rawHandle = fallbackState.rawHandle;
+        const rawCandidates = Array.isArray(rawHandle?.candidates) ? rawHandle?.candidates : Array.isArray(rawHandle?.variants) ? rawHandle?.variants : [];
+        const isFusionFallback = surface === "fusion" || fallbackState.runMetadata?.runSemantics === "fusion";
+        if (isFusionFallback && !inspectRequested && tryRenderFusionReadHuman(fusionAnalysisRead, {
+          inspect: false
+        })) {
+          return;
+        }
+        const winnerReconciliation2 = buildWinnerReconciliationForResults({
+          evaluation: void 0,
+          compState: fallbackState,
+          winnerFlipRow,
+          multiJudgeRun
+        });
+        renderFallbackResults(
+          resolvedTaskId,
+          rawCandidates,
+          fallbackState.outcome === "winner_selected" || fallbackState.decision?.reason === "judge_off" ? fallbackState.winner ?? null : null,
+          fallbackState.decision?.reason ?? null,
+          fallbackState,
+          fusionAnalysisRead,
+          winnerReconciliation2.requiredGatePolicy,
+          {
+            inspect: inspectRequested,
+            undeliveredLineFor: undeliveredLineLookup(telemetry.variantsModule, resolvedTaskId)
+          }
+        );
+        if (synthesisArtifact) {
+          renderSynthesisTelemetryHuman(synthesisArtifact, synthesisArtifactRead.artifact);
+        }
+        if (synthesisArtifactRead.parseWarning) {
+          console.log(
+            chalk6.yellow(
+              `Warning: Synthesis artifact unreadable: ${synthesisArtifactRead.parseWarning}`
+            )
+          );
+          console.log();
+        }
+        renderInterruptedCompetitionNotice(fallbackState);
+        formatWinnerReconciliationHuman(winnerReconciliation2, multiJudgeRun);
+        if (multiJudgeRun) {
+          renderMultiJudgeRun(multiJudgeRun);
+        }
+        renderMatrixResultsSummary(matrixSummary);
+        return;
+      }
+      if (options2.json) {
+        const winnerReconciliation2 = buildWinnerReconciliationForResults({
+          evaluation,
+          compState,
+          winnerFlipRow,
+          multiJudgeRun
+        });
+        const hasFinalWinner2 = compState.outcome === "winner_selected";
+        const rawCandidates = getRawCompetitionCandidates(compState);
+        const finalWinnerForRows = hasFinalWinner2 && winnerReconciliation2.finalRetainedWinner.variant ? winnerReconciliation2.finalRetainedWinner.variant : hasFinalWinner2 && compState.winner?.variant ? compState.winner.variant : null;
+        const isFusionRun = compState.runMetadata?.runSemantics === "fusion";
+        const variantsJsonBase = isFusionRun ? rawCandidates.map(
+          (candidate) => buildCompetitionHandleVariantJson(candidate, {
+            runSemantics: compState.runMetadata?.runSemantics ?? null
+          })
+        ) : hasEvaluationVariantScores(evaluation) ? Object.entries(evaluation.variantScores ?? {}).map(([variantId, data]) => {
+          const variantData = data && typeof data === "object" ? data : null;
+          const inputSpecWarning = findVariantInputSpecWarning(
+            [variantId, variantData?.label],
+            compState.variants
+          );
+          return {
+            variant: variantId,
+            ...!isFusionRun ? {
+              isWinner: hasFinalWinner2 && finalWinnerForRows != null && variantHandlesMatchForResults(variantId, finalWinnerForRows)
+            } : {},
+            label: variantData?.label ?? null,
+            overallScore: typeof variantData?.overallScore === "number" && Number.isFinite(variantData.overallScore) ? variantData.overallScore : null,
+            rankingScore: typeof variantData?.rankingScore === "number" && Number.isFinite(variantData.rankingScore) ? variantData.rankingScore : null,
+            compositeScore: typeof variantData?.compositeScore === "number" && Number.isFinite(variantData.compositeScore) ? variantData.compositeScore : null,
+            qualityScore: typeof variantData?.qualityScore === "number" && Number.isFinite(variantData.qualityScore) ? variantData.qualityScore : null,
+            scoreSource: typeof variantData?.scoreSource === "string" ? variantData.scoreSource : null,
+            ...inputSpecWarning ? { inputSpecWarning } : {},
+            scores: variantData?.scores ?? null,
+            confidence: getDisplayableSelfConfidence(variantData ?? {}),
+            rationale: variantData?.rationale ?? null
+          };
+        }) : rawCandidates.map(
+          (candidate) => buildCompetitionHandleVariantJson(candidate, {
+            runSemantics: compState.runMetadata?.runSemantics ?? null
+          })
+        );
+        const variantsJson = !isFusionRun && hasFinalWinner2 && finalWinnerForRows != null && !variantsJsonBase.some(
+          (row) => resultVariantRowMatchesFinalWinner(row, finalWinnerForRows)
+        ) ? [
+          ...variantsJsonBase.map((row) => ({
+            ...row,
+            isWinner: false
+          })),
+          {
+            variant: finalWinnerForRows,
+            isWinner: true,
+            label: null,
+            overallScore: null,
+            rankingScore: null,
+            compositeScore: null,
+            qualityScore: null,
+            scoreSource: "competition_handle",
+            scores: null,
+            confidence: null,
+            rationale: null
+          }
+        ] : variantsJsonBase;
+        const outcome = isFusionRun ? null : compState.outcome ?? null;
+        const finalWinnerVariant = isFusionRun ? null : finalWinnerForRows;
+        const winnerEvidence2 = finalWinnerVariant ? resolveWinnerEvidenceForResults({
+          finalWinnerVariant,
+          selectedEvaluation: evaluation,
+          judgeEvaluations,
+          multiJudgeRun,
+          winnerReconciliation: winnerReconciliation2
+        }) : null;
+        const winnerJson = finalWinnerVariant && winnerEvidence2 ? {
+          variant: finalWinnerVariant,
+          score: winnerEvidence2.score,
+          decisionScore: winnerEvidence2.decisionScore,
+          confidence: winnerEvidence2.confidence,
+          rationale: winnerEvidence2.rationale,
+          scoreSource: winnerEvidence2.scoreSource,
+          provenance: winnerEvidence2.provenance
+        } : null;
+        const scoreCalibration = buildScoreCalibrationSummary({
+          report: winnerReconciliation2,
+          multiJudgeRun
+        });
+        if (winnerEvidence2 && scoreCalibration.primaryAlignedWithFinal === true && typeof winnerEvidence2.score === "number") {
+          scoreCalibration.finalWinnerScore = winnerEvidence2.score;
+          scoreCalibration.scoreDeltaPrimaryMinusFinal = typeof scoreCalibration.primaryWinnerScore === "number" ? scoreCalibration.primaryWinnerScore - winnerEvidence2.score : null;
+        }
+        console.log(
+          JSON.stringify(
+            {
+              taskId: resolvedTaskId,
+              requestedTaskId: validatedTaskId,
+              resolvedTaskId,
+              executionMode: compState.executionMode ?? null,
+              initiatedBy: compState.initiatedBy ?? null,
+              outcome,
+              ...isFusionRun ? {
+                fusionResult: resolveCompetitionResultFromState(compState),
+                ...getFusionRunReadModel(resolvedTaskId, stateReaderOpts)
+              } : {
+                competitionResult: resolveCompetitionResultFromState(compState),
+                judgeOperationsV1: projectJudgeOperationsFromState(
+                  { id: resolvedTaskId, kind: "compete" },
+                  compState
+                ),
+                ...getCompetitionRunReadModel(resolvedTaskId, stateReaderOpts)
+              },
+              executionHealth: resolveExecutionHealthFromState(compState),
+              runMetadata: compState.runMetadata ? {
+                ...compState.runMetadata,
+                ...isFusionRun ? { judge: void 0, replay: void 0 } : {}
+              } : null,
+              lab: compState.labId || compState.labRunId ? {
+                labId: compState.labId ?? null,
+                runId: compState.labRunId ?? null
+              } : null,
+              ...!isFusionRun ? {
+                judge: compState.runMetadata?.judge ?? (compState.decision ? {
+                  requested: compState.decision.primaryJudge ?? null,
+                  status: compState.decision.reason === "judge_off" ? "disabled" : null,
+                  reason: compState.decision.reason ?? null
+                } : null),
+                winner: winnerJson
+              } : {},
+              variants: variantsJson,
+              ...!isFusionRun ? {
+                metadata: {
+                  model: evaluation.model ?? null,
+                  totalVariants: evaluation.totalVariants ?? null,
+                  evaluationTimeMs: evaluation.evaluationTimeMs ?? null,
+                  evaluationDurationMs: evaluation.evaluationDurationMs ?? null,
+                  tokensUsed: evaluation.tokensUsed ?? null,
+                  costUsd: evaluation.costUsd ?? null
+                },
+                selectedEvaluation: {
+                  kind: getSelectedEvaluationKind(evaluation),
+                  winner: evaluation.winnerVariant ?? null,
+                  score: evaluation.winnerScore ?? null,
+                  confidence: evaluation.winnerConfidence ?? null,
+                  rationale: evaluation.winnerRationale ?? null
+                },
+                configuration: {
+                  criteriaWeights: evaluation.criteriaWeights ?? null,
+                  minAcceptableScore: evaluation.minAcceptableScore ?? null,
+                  confidenceThreshold: evaluation.confidenceThreshold ?? null
+                }
+              } : {},
+              synthesis: isFusionRun ? buildFusionSynthesisResultsJson({
+                synthesisGenerated: evaluation.synthesisGenerated,
+                synthesisCode: evaluation.synthesisCode,
+                artifact: synthesisArtifact,
+                artifactParseWarning: synthesisArtifactRead.parseWarning,
+                analysisSynthesis: compState.runMetadata?.synthesis
+              }) : buildSynthesisResultsJson({
+                synthesisGenerated: evaluation.synthesisGenerated,
+                synthesisCode: evaluation.synthesisCode,
+                artifact: synthesisArtifact,
+                artifactParseWarning: synthesisArtifactRead.parseWarning,
+                rawArtifact: synthesisArtifactRead.artifact
+              }),
+              ...isFusionRun ? buildFusionArtifactJsonFields(fusionAnalysisRead) : {},
+              ...!isFusionRun ? {
+                multiJudge: multiJudgeRun ?? null,
+                matrix: matrixSummary,
+                judgeEvaluations,
+                scoreCalibration,
+                ...winnerReconciliation2.hasTelemetry ? { winnerReconciliation: winnerReconciliation2 } : {}
+              } : {},
+              ...bypassedRequestedAmbiguity ? {
+                warnings: [
+                  {
+                    code: "requested_lab_task_id_ambiguous",
+                    message: bypassedRequestedAmbiguity.message,
+                    taskId: bypassedRequestedAmbiguity.requestedTaskId,
+                    matchType: bypassedRequestedAmbiguity.matchType,
+                    matches: bypassedRequestedAmbiguity.matches.map((match) => ({
+                      taskId: match.taskId,
+                      runRoot: match.runRoot
+                    })),
+                    resolvedTaskId
+                  }
+                ]
+              } : {}
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+      if (bypassedRequestedAmbiguity) {
+        console.error(
+          chalk6.yellow(
+            `Warning: ${bypassedRequestedAmbiguity.message} Resolved via stored evaluation taskId ${resolvedTaskId}.`
+          )
+        );
+      }
+      const resultsTitle = extractTitleFromPrompt(compState.prompt);
+      console.log(
+        chalk6.blue.bold(
+          `
+Competition Results: ${formatTaskLabel({ title: resultsTitle, id: validatedTaskId })}
+`
+        )
+      );
+      const hasFinalWinner = compState.outcome === "winner_selected";
+      if (compState.executionMode) {
+        console.log(chalk6.cyan(`Mode: ${formatExecutionModeLabel(compState.executionMode)}`));
+        console.log();
+      }
+      const winnerReconciliation = buildWinnerReconciliationForResults({
+        evaluation,
+        compState,
+        winnerFlipRow,
+        multiJudgeRun
+      });
+      renderInterruptedCompetitionNotice(compState);
+      formatWinnerReconciliationHuman(winnerReconciliation, multiJudgeRun);
+      console.log(chalk6.white.bold("Evaluation Metadata:"));
+      if (resolved?.resolvedDbPath) {
+        const relativeDbPath = path2.relative(process.cwd(), resolved.resolvedDbPath);
+        const resolvedLabel = relativeDbPath.length > 0 && !relativeDbPath.startsWith("..") ? relativeDbPath : resolved.resolvedDbPath;
+        const suffix = resolved.usedLabFallback ? " (lab fallback)" : "";
+        console.log(chalk6.white(`  Telemetry DB: ${resolvedLabel}${suffix}`));
+      }
+      const judgeModelLine = formatJudgeEvaluationModelLine(evaluation);
+      if (judgeModelLine) {
+        console.log(chalk6.white(judgeModelLine));
+      }
+      console.log(chalk6.white(`  Total Variants: ${evaluation.totalVariants}`));
+      if (typeof evaluation.evaluationTimeMs === "number") {
+        console.log(
+          chalk6.white(`  Evaluation Time: ${evaluation.evaluationTimeMs.toFixed(0)}ms`)
+        );
+      }
+      if (typeof evaluation.evaluationDurationMs === "number") {
+        console.log(chalk6.white(`  Duration: ${evaluation.evaluationDurationMs.toFixed(0)}ms`));
+      }
+      if (evaluation.tokensUsed) {
+        console.log(chalk6.white(`  Tokens Used: ${evaluation.tokensUsed.toLocaleString()}`));
+      }
+      if (typeof evaluation.costUsd === "number") {
+        console.log(chalk6.white(`  Cost: $${evaluation.costUsd.toFixed(4)}`));
+      }
+      console.log();
+      if (evaluation.criteriaWeights || evaluation.minAcceptableScore || evaluation.confidenceThreshold) {
+        console.log(chalk6.white.bold("Configuration:"));
+        if (evaluation.criteriaWeights) {
+          console.log(chalk6.white("  Criteria Weights:"));
+          for (const [criterion, weight] of Object.entries(evaluation.criteriaWeights)) {
+            console.log(chalk6.gray(`    ${criterion}: ${weight}`));
+          }
+        }
+        if (evaluation.minAcceptableScore !== void 0) {
+          console.log(chalk6.white(`  Minimum Score: ${evaluation.minAcceptableScore}`));
+        }
+        if (evaluation.confidenceThreshold !== void 0) {
+          console.log(chalk6.white(`  Confidence Threshold: ${evaluation.confidenceThreshold}`));
+        }
+        console.log();
+      }
+      const decisionStatus = evaluation.winnerRationale?.decisionStatus;
+      const decisionOutcome = evaluation.winnerRationale?.decisionOutcome;
+      const escalation = evaluation.winnerRationale?.escalation;
+      const coverageSummary = formatJudgeCoverageSummary(evaluation.winnerRationale?.coverage);
+      const margin = evaluation.winnerRationale?.margin;
+      const top2 = evaluation.winnerRationale?.top2;
+      const variantLabelMapping = extractVariantLabelMapping(
+        evaluation
+      );
+      const statusText = typeof decisionStatus === "string" ? decisionStatus : null;
+      const outcomeText = typeof decisionOutcome === "string" ? decisionOutcome : null;
+      const marginText = typeof margin === "number" && Number.isFinite(margin) ? margin : null;
+      const top2List = Array.isArray(top2) ? top2 : null;
+      const winnerVariant = compState.winner?.variant != null ? String(compState.winner.variant).trim() : null;
+      const winnerEvidence = hasFinalWinner && winnerVariant ? resolveWinnerEvidenceForResults({
+        finalWinnerVariant: winnerVariant,
+        selectedEvaluation: evaluation,
+        judgeEvaluations,
+        multiJudgeRun,
+        winnerReconciliation
+      }) : null;
+      if (shouldRenderUnretainedJudgeTopPick({
+        hasFinalWinner,
+        evaluationWinnerVariant: evaluation.winnerVariant,
+        decisionReason: compState.decision?.reason
+      })) {
+        console.log(chalk6.yellow.bold("No Final Winner"));
+        const top = winnerReconciliation.judgeSelectedTopPick.variant ?? evaluation.winnerVariant;
+        const outcomeLabel = compState.outcome ?? "no_winner";
+        const suffix = "judge-selected top pick was not retained";
+        console.log(
+          chalk6.yellow(
+            `  Final outcome: ${outcomeLabel} \u2014 ${suffix} (${top}; see Winner reconciliation above).`
+          )
+        );
+        console.log();
+      }
+      if (hasFinalWinner && winnerVariant) {
+        console.log(chalk6.green.bold("Winner:"));
+        console.log(chalk6.green(`  Variant: ${winnerVariant}`));
+        const applicationLine = formatApplicationVerificationLine(compState.application);
+        if (applicationLine) console.log(chalk6.green(`  ${applicationLine}`));
+        if (typeof winnerEvidence?.decisionScore === "number") {
+          console.log(
+            chalk6.green(`  Decision Score: ${winnerEvidence.decisionScore.toFixed(2)}%`)
+          );
+        }
+        if (typeof winnerEvidence?.confidence === "number") {
+          console.log(
+            chalk6.green(
+              `  Decision Confidence: ${formatConfidencePercent(winnerEvidence.confidence)}`
+            )
+          );
+        }
+        const winnerSelfConfidence = winnerVariant && evaluation.variantScores ? getDisplayableSelfConfidence(
+          evaluation.variantScores[winnerVariant] ?? Object.entries(evaluation.variantScores).find(
+            ([variant]) => variantHandlesMatchForResults(variant, winnerVariant)
+          )?.[1] ?? {}
+        ) : void 0;
+        if (winnerSelfConfidence !== void 0) {
+          console.log(
+            chalk6.green(`  Self-Confidence: ${formatConfidencePercent(winnerSelfConfidence)}`)
+          );
+        }
+        if (statusText || outcomeText) {
+          const parts = [];
+          if (statusText) parts.push(`status=${statusText}`);
+          if (outcomeText) parts.push(`outcome=${outcomeText}`);
+          if (marginText !== null) parts.push(`margin=${marginText.toFixed(1)}`);
+          if (top2List && top2List.length >= 2) {
+            const first = top2List[0];
+            const second = top2List[1];
+            const firstLabel = typeof first?.variant === "string" ? `${first.variant}` : "unknown";
+            const firstScore = typeof first?.score === "number" && Number.isFinite(first.score) ? `(${first.score.toFixed(1)})` : "";
+            const secondLabel = typeof second?.variant === "string" ? `${second.variant}` : "unknown";
+            const secondScore = typeof second?.score === "number" && Number.isFinite(second.score) ? `(${second.score.toFixed(1)})` : "";
+            parts.push(`top2=${firstLabel}${firstScore} vs ${secondLabel}${secondScore}`);
+          }
+          console.log(chalk6.yellow(`  Decision: ${parts.join(" \u2022 ")}`));
+        }
+        if (escalation && typeof escalation.recommended === "string" && escalation.recommended !== "none") {
+          const reasons = Array.isArray(escalation.reasons) ? escalation.reasons.filter((reason) => typeof reason === "string") : [];
+          console.log(
+            chalk6.yellow(
+              `  Escalation: ${escalation.recommended}${reasons.length > 0 ? ` [${reasons.join(", ")}]` : ""}`
+            )
+          );
+        }
+        if (coverageSummary) {
+          console.log(chalk6.yellow(`  Coverage: ${coverageSummary}`));
+        }
+        const winnerRationale = winnerEvidence?.rationale ?? null;
+        if (winnerRationale) {
+          console.log(chalk6.green("\n  Rationale:"));
+          console.log(
+            chalk6.yellow.dim(
+              "    Warning: AI analysis may contain unverified claims. Verify critical findings with linter/tests."
+            )
+          );
+          if (winnerRationale.reasoning) {
+            console.log(chalk6.gray(`    ${winnerRationale.reasoning}`));
+          }
+          if (winnerRationale.strengths && Array.isArray(winnerRationale.strengths)) {
+            console.log(chalk6.gray("\n    Strengths:"));
+            for (const strength of winnerRationale.strengths) {
+              console.log(chalk6.gray(`      - ${strength}`));
+            }
+          }
+          if (winnerRationale.weaknesses && Array.isArray(winnerRationale.weaknesses)) {
+            console.log(chalk6.gray("\n    Weaknesses:"));
+            for (const weakness of winnerRationale.weaknesses) {
+              console.log(chalk6.gray(`      - ${weakness}`));
+            }
+          }
+          if (variantLabelMapping.length > 0) {
+            console.log(chalk6.gray("\n    Label Mapping:"));
+            for (const entry of variantLabelMapping) {
+              console.log(chalk6.gray(`      ${entry.label} -> ${entry.variant}`));
+            }
+          }
+        }
+        console.log();
+      }
+      if (evaluation.variantScores && Object.keys(evaluation.variantScores).length > 0) {
+        console.log(chalk6.blue.bold("Variant Scores:\n"));
+        for (const [variant, data] of Object.entries(evaluation.variantScores)) {
+          if (!data || typeof data !== "object" || !("scores" in data)) {
+            continue;
+          }
+          const isWinner = hasFinalWinner && winnerVariant != null && variantHandlesMatchForResults(variant, winnerVariant);
+          const variantColor = isWinner ? chalk6.green : chalk6.white;
+          const variantExecution = telemetry.getVariantExecution(validatedTaskId, variant);
+          const terminationReason = variantExecution?.termination_reason;
+          const terminationLabel = terminationReason ? ` (${terminationReason})` : "";
+          let variantResultRecord = null;
+          try {
+            variantResultRecord = telemetry.variantsModule.getVariantResultRecord(
+              validatedTaskId,
+              variantExecution?.variant ?? variant
+            );
+          } catch {
+            variantResultRecord = null;
+          }
+          console.log(
+            variantColor.bold(`  ${variant}${isWinner ? " (winner)" : ""}${terminationLabel}:`)
+          );
+          if (typeof data === "object" && data !== null) {
+            const variantData = data;
+            const variantLabel = typeof variantData.label === "string" ? variantData.label.trim() : "";
+            if (variantLabel.length > 0) {
+              console.log(chalk6.gray(`    Label: ${variantLabel}`));
+            }
+            const providerExecutionPathLine = formatProviderExecutionPathLine(
+              variant,
+              variantResultRecord
+            );
+            if (providerExecutionPathLine) {
+              console.log(chalk6.gray(`    ${providerExecutionPathLine}`));
+            }
+            if (variantData.scores) {
+              console.log(chalk6.gray("    Scores:"));
+              for (const [criterion, score] of Object.entries(variantData.scores)) {
+                console.log(chalk6.gray(`      ${criterion}: ${score}`));
+              }
+            }
+            const primaryScore = getVariantOverallScore(variantData);
+            if (typeof primaryScore === "number" && Number.isFinite(primaryScore)) {
+              const primaryLabel = variantData.scoreSource === "bucket_scores" || typeof variantData.rankingScore === "number" || typeof variantData.compositeScore === "number" ? "Ranking Score" : "Overall";
+              console.log(chalk6.gray(`    ${primaryLabel}: ${primaryScore.toFixed(1)}`));
+            }
+            if (typeof variantData.qualityScore === "number" && Number.isFinite(variantData.qualityScore) && (primaryScore === null || Math.abs(primaryScore - variantData.qualityScore) > 0.05)) {
+              console.log(
+                chalk6.gray(`    Quality Score: ${variantData.qualityScore.toFixed(1)}`)
+              );
+            }
+            const variantSelfConfidence = getDisplayableSelfConfidence(variantData);
+            if (variantSelfConfidence !== void 0) {
+              console.log(
+                chalk6.gray(
+                  `    Self-Confidence: ${formatConfidencePercent(variantSelfConfidence)}`
+                )
+              );
+            }
+            printCandidateEvidenceLines(variantResultRecord);
+            const undeliveredLine = undeliveredLineFromTelemetry(
+              telemetry.variantsModule,
+              validatedTaskId,
+              [variantExecution?.variant, variant]
+            );
+            if (undeliveredLine) console.log(chalk6.gray(`    ${undeliveredLine}`));
+            if (variantData.rationale?.reasoning) {
+              console.log(
+                chalk6.yellow.dim(
+                  "    Warning: AI analysis may contain unverified claims. Verify critical findings with linter/tests."
+                )
+              );
+              console.log(chalk6.gray(`    Reasoning: ${variantData.rationale.reasoning}`));
+            }
+          }
+          const isTimedOut = variantResultRecord?.timedOut === true;
+          const hasPartialEdits = variantResultRecord?.partialEdits === true;
+          const partialStats = variantResultRecord ? extractPartialEditStats(variantResultRecord) : null;
+          if (isTimedOut && (hasPartialEdits || partialStats)) {
+            console.log(
+              chalk6.yellow(
+                `    Partial edits: ${partialStats?.filesChanged ?? 0} files, +${partialStats?.linesAdded ?? 0}/-${partialStats?.linesRemoved ?? 0}`
+              )
+            );
+          }
+          console.log();
+        }
+      }
+      if (evaluation.synthesisGenerated && evaluation.synthesisCode) {
+        console.log(chalk6.blue.bold("Tip: Synthesis:\n"));
+        console.log(chalk6.gray(evaluation.synthesisCode));
+        console.log();
+      }
+      if (synthesisArtifact) {
+        renderSynthesisTelemetryHuman(synthesisArtifact, synthesisArtifactRead.artifact);
+      }
+      if (synthesisArtifactRead.parseWarning) {
+        console.log(
+          chalk6.yellow(
+            `Warning: Synthesis artifact unreadable: ${synthesisArtifactRead.parseWarning}`
+          )
+        );
+        console.log();
+      }
+      renderPerJudgeVariantScores(judgeEvaluations);
+      if (multiJudgeRun) {
+        renderMultiJudgeRun(multiJudgeRun);
+      }
+      renderMatrixResultsSummary(matrixSummary);
+      if (evaluation.variantScores && Object.keys(evaluation.variantScores).length > 0) {
+        for (const [variantId, data] of Object.entries(evaluation.variantScores)) {
+          if (!data || typeof data !== "object" || !("scores" in data)) {
+            continue;
+          }
+          try {
+            const variantExecution = telemetry.getVariantExecution(validatedTaskId, variantId);
+            if (variantExecution) {
+              const resultJson = variantExecution.resultJson ? parseJsonWithContext(
+                variantExecution.resultJson,
+                `Variant result JSON (${variantExecution.variant})`
+              ) : null;
+              if (resultJson && Array.isArray(resultJson.warnings) && resultJson.warnings.length > 0) {
+                console.log(chalk6.blue.bold(`
+Warning: Warnings for ${variantId}:`));
+                console.log(warningFormatter.formatWarnings(resultJson.warnings));
+                console.log(
+                  chalk6.gray(`  Summary: ${warningFormatter.formatSummary(resultJson.warnings)}`)
+                );
+              }
+              if (resultJson?.validationResult) {
+                console.log(chalk6.blue.bold(`
+Validation for ${variantId}:`));
+                console.log(chalk6.gray(JSON.stringify(resultJson.validationResult, null, 2)));
+              }
+            }
+          } catch {
+          }
+        }
+      } else if (statusText || outcomeText) {
+        if (statusText === "tie") {
+          const tiedVariants = evaluation.winnerRationale?.tiedVariants;
+          const tiedLabel = Array.isArray(tiedVariants) && tiedVariants.length > 0 ? tiedVariants.filter((v) => typeof v === "string" && v.trim().length > 0).join(", ") : "all tied variants";
+          console.log(chalk6.cyan.bold("Tie:"));
+          console.log(chalk6.cyan(`  Variants: ${tiedLabel}`));
+        } else {
+          console.log(chalk6.yellow.bold("Warning: No Winner Declared"));
+        }
+        const parts = [];
+        if (statusText) parts.push(`status=${statusText}`);
+        if (outcomeText) parts.push(`outcome=${outcomeText}`);
+        if (marginText !== null) parts.push(`margin=${marginText.toFixed(1)}`);
+        if (top2List && top2List.length >= 2) {
+          const first = top2List[0];
+          const second = top2List[1];
+          const firstLabel = typeof first?.variant === "string" ? `${first.variant}` : "unknown";
+          const firstScore = typeof first?.score === "number" && Number.isFinite(first.score) ? `(${first.score.toFixed(1)})` : "";
+          const secondLabel = typeof second?.variant === "string" ? `${second.variant}` : "unknown";
+          const secondScore = typeof second?.score === "number" && Number.isFinite(second.score) ? `(${second.score.toFixed(1)})` : "";
+          parts.push(`top2=${firstLabel}${firstScore} vs ${secondLabel}${secondScore}`);
+        }
+        if (parts.length > 0) {
+          console.log(chalk6.yellow(`  Decision: ${parts.join(" \u2022 ")}`));
+        }
+        if (coverageSummary) {
+          console.log(chalk6.yellow(`  Coverage: ${coverageSummary}`));
+        }
+        if (evaluation.winnerRationale?.reasoning) {
+          console.log(
+            chalk6.yellow.dim("    Warning: AI analysis may contain unverified claims.")
+          );
+          console.log(chalk6.gray(`  Rationale: ${evaluation.winnerRationale.reasoning}`));
+        }
+        if (variantLabelMapping.length > 0) {
+          console.log(chalk6.gray("  Label Mapping:"));
+          for (const entry of variantLabelMapping) {
+            console.log(chalk6.gray(`    ${entry.label} -> ${entry.variant}`));
+          }
+        }
+        console.log();
+      }
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        console.error(chalk6.red("\nError: Invalid task ID format"));
+        console.error(
+          chalk6.gray(
+            "Task ID must contain only alphanumeric characters, hyphens, and underscores\n"
+          )
+        );
+      } else if (error instanceof AmbiguousLabTaskIdError) {
+        if (options2.json) {
+          console.log(JSON.stringify(error.toJson(), null, 2));
+        } else {
+          console.error(chalk6.red(`
+Error: ${error.message}
+`));
+        }
+      } else {
+        console.error(chalk6.red("\nError: Retrieving evaluation results failed:"));
+        console.error(chalk6.gray(error instanceof Error ? error.message : String(error)));
+        console.log();
+      }
+      process.exitCode = 1;
+    } finally {
+      try {
+        resolved?.dispose();
+      } catch {
+      }
+    }
+  });
+  return cmd;
+}
+function renderFallbackResults(taskId, candidates, winner, noWinnerReason, state, fusionAnalysisRead, requiredGatePolicyValue, options = {}) {
+  const isFusion = state?.runMetadata?.runSemantics === "fusion";
+  if (isFusion && options.inspect !== true && tryRenderFusionReadHuman(fusionAnalysisRead, {
+    inspect: false
+  })) {
+    return;
+  }
+  const requiredGatePolicy = normalizeRequiredGatePolicy(requiredGatePolicyValue);
+  console.log(chalk6.blue.bold(`
+${isFusion ? "Fusion" : "Competition"} Results: ${taskId}
+`));
+  console.log(
+    chalk6.yellow(
+      isFusion ? "Fusion synthesis uses contributor execution data and peer integration.\n" : "AI Judge row telemetry not available for this competition. Showing persisted competition state:\n"
+    )
+  );
+  const judgeSummary = state ? buildFallbackJudgeSummary(state) : null;
+  const decisionSummary = state ? buildFallbackDecisionSummary(state) : null;
+  if (isFusion && state) {
+    const synthesis = state.runMetadata?.synthesis;
+    const hasIntegratedContributorCount = typeof synthesis?.contributorCount === "number";
+    const contributors = hasIntegratedContributorCount ? synthesis.contributorCount : candidates.filter((candidate) => candidate.success === true).length;
+    console.log(chalk6.blue.bold("Fusion Summary:"));
+    console.log(chalk6.blue("  Run semantics: fusion"));
+    if (synthesis?.status) {
+      console.log(chalk6.blue(`  Synthesis: ${synthesis.status}`));
+    }
+    if (typeof synthesis?.artifactPath === "string") {
+      console.log(chalk6.blue(`  Synthesis artifact: ${synthesis.artifactPath}`));
+    }
+    if (typeof synthesis?.jsonPath === "string") {
+      console.log(chalk6.blue(`  Synthesis JSON: ${synthesis.jsonPath}`));
+    }
+    console.log(
+      chalk6.blue(
+        `${hasIntegratedContributorCount ? "  Contributors integrated" : "  Contributors completed"}: ${contributors}/${candidates.length}`
+      )
+    );
+    if (options.inspect === true && tryRenderFusionReadHuman(fusionAnalysisRead, {
+      inspect: true
+    })) {
+    } else {
+      renderFusionAnalysisSynthesisDetails({
+        taskId,
+        requestedTaskId: taskId,
+        read: fusionAnalysisRead ?? null
+      });
+    }
+    console.log();
+  } else if (judgeSummary || decisionSummary) {
+    console.log(chalk6.blue.bold("Persisted Decision:"));
+    const requested = typeof judgeSummary?.requested === "string" ? judgeSummary.requested : void 0;
+    const status = typeof judgeSummary?.status === "string" ? judgeSummary.status : void 0;
+    const decisionStatus = typeof decisionSummary?.decisionStatus === "string" ? decisionSummary.decisionStatus : void 0;
+    const decisionOutcome = typeof decisionSummary?.decisionOutcome === "string" ? decisionSummary.decisionOutcome : void 0;
+    const selectedVariant = typeof decisionSummary?.selectedVariant === "string" ? decisionSummary.selectedVariant : void 0;
+    const reason = typeof decisionSummary?.reason === "string" ? decisionSummary.reason : void 0;
+    const winnerVariant = winner?.variant ?? [winner?.provider, winner?.resolvedModel ?? winner?.model].filter((part) => Boolean(part)).join(":");
+    const selectedCandidate = findDecisionCandidateForResults(
+      candidates,
+      selectedVariant,
+      winnerVariant
+    );
+    console.log(chalk6.blue(`  Judge: ${requested ?? "unknown"}${status ? ` (${status})` : ""}`));
+    if (decisionStatus || decisionOutcome) {
+      const suppressVerifiedDecisionSuffix = decisionOutcome === "verified" && hasAnalysisIntentEvidence(state, candidates);
+      const contradictsVerifiedDecision = decisionOutcome === "verified" && !suppressVerifiedDecisionSuffix && selectedCandidate !== null && candidateHasFailingVerificationForDisplay(selectedCandidate, requiredGatePolicy);
+      const decisionOutcomeSuffix = decisionOutcome && !suppressVerifiedDecisionSuffix && !contradictsVerifiedDecision ? ` / ${decisionOutcome}` : "";
+      console.log(chalk6.blue(`  Outcome: ${decisionStatus ?? "unknown"}${decisionOutcomeSuffix}`));
+      if (suppressVerifiedDecisionSuffix) {
+        console.log(chalk6.blue("  Verification: not applicable (analysis intent)"));
+      } else if (contradictsVerifiedDecision) {
+        console.log(chalk6.blue("  Verification: unverified (required gate evidence failed)"));
+      }
+    }
+    if (selectedVariant && !isFusion) {
+      console.log(chalk6.blue(`  Selected: ${selectedVariant}`));
+    }
+    if (reason) {
+      console.log(chalk6.gray(`  Reason: ${reason}`));
+    }
+    console.log();
+  }
+  const applicationLine = formatApplicationVerificationLine(state?.application);
+  if (applicationLine) console.log(chalk6.yellow(`${applicationLine}
+`));
+  if (winner && !isFusion && noWinnerReason === "judge_off") {
+    const identityVariant = winner.variant ?? [winner.provider, winner.resolvedModel ?? winner.model].filter((part) => Boolean(part)).join(":");
+    console.log(
+      [
+        chalk6.yellow.bold("Ungraded Result:"),
+        chalk6.yellow(`  Identity: ${identityVariant || "unknown"}`),
+        chalk6.gray("  Judge status: disabled (--judge off); no judge ran."),
+        ""
+      ].join("\n")
+    );
+  } else if (winner && !isFusion) {
+    const winnerVariant = winner.variant ?? [winner.provider, winner.resolvedModel ?? winner.model].filter((part) => Boolean(part)).join(":");
+    console.log(
+      [chalk6.green.bold("Winner:"), chalk6.green(`  Variant: ${winnerVariant || "unknown"}`)].join(
+        "\n"
+      )
+    );
+    console.log(
+      chalk6.gray(
+        decisionSummary?.decisionStatus === "declared" ? "  Provenance: competition handle; persisted judge decision" : "  Provenance: competition handle; judge row telemetry unavailable"
+      )
+    );
+    console.log();
+  } else if (!isFusion && noWinnerReason === "judge_off") {
+    console.log(chalk6.yellow.bold("No Final Winner"));
+    console.log(chalk6.yellow("  Judge status: disabled (--judge off); no winner was selected."));
+    console.log();
+  }
+  if (candidates.length === 0) {
+    console.log(chalk6.gray("No variant entries recorded in competition handle."));
+    return;
+  }
+  for (const candidate of candidates) {
+    const candidateRecord = candidate;
+    const provider = String(candidateRecord.provider ?? "unknown");
+    const requestedProvider = typeof candidateRecord.requestedProvider === "string" ? candidateRecord.requestedProvider : null;
+    const requestedModel = typeof candidateRecord.requestedModel === "string" ? candidateRecord.requestedModel : null;
+    const executedModel = typeof candidateRecord.resolvedModel === "string" ? candidateRecord.resolvedModel : typeof candidateRecord.model === "string" ? candidateRecord.model : null;
+    const hasRequestedExecutedMismatch = requestedProvider !== null && (requestedProvider !== provider || requestedModel !== null && requestedModel !== executedModel);
+    const variantLabel = typeof candidateRecord.variant === "string" && candidateRecord.variant.trim().length > 0 ? candidateRecord.variant.trim() : `${provider}:${executedModel ?? "default"}`;
+    const hasReportedSuccess = typeof candidateRecord.success === "boolean";
+    const providerCompleted = isFusion ? candidateRecord.success === true : Boolean(candidateRecord.success);
+    const verificationFailed = candidateHasFailingVerificationForDisplay(
+      candidateRecord,
+      requiredGatePolicy
+    );
+    const success = providerCompleted && !verificationFailed;
+    const terminationReason = candidateRecord.terminationReason;
+    const isCanceled = typeof terminationReason === "string" && (terminationReason === "canceled_early_exit" || terminationReason === "canceled_budget" || terminationReason === "canceled_user");
+    const isTimedOut = candidateRecord.timedOut === true || typeof terminationReason === "string" && terminationReason === "timeout";
+    const status = success ? chalk6.green("Success") : isFusion ? hasReportedSuccess ? chalk6.gray("Not completed") : chalk6.gray("Unknown") : isCanceled ? chalk6.yellow("Canceled") : chalk6.red("Failed");
+    const completenessValue = candidateRecord.completeness;
+    const completeness = typeof completenessValue === "number" ? `${completenessValue}%` : "not reported";
+    const prNumber = candidateRecord.prNumber;
+    const prInfo = typeof prNumber === "number" ? `PR #${prNumber}${typeof candidateRecord.prUrl === "string" && candidateRecord.prUrl.length > 0 ? ` (${candidateRecord.prUrl})` : ""}` : "No PR recorded";
+    const durationValue = candidateRecord.duration;
+    const duration = typeof durationValue === "number" ? `${durationValue.toFixed(1)}s` : "n/a";
+    console.log(chalk6.white.bold(`- ${variantLabel}`));
+    if (hasRequestedExecutedMismatch) {
+      console.log(
+        chalk6.gray(
+          `    Requested: ${[requestedProvider, requestedModel].filter(Boolean).join(":")}`
+        )
+      );
+      console.log(
+        chalk6.gray(`    Executed: ${[provider, executedModel].filter(Boolean).join(":")}`)
+      );
+    }
+    console.log(chalk6.gray(`    ${status}`));
+    if (terminationReason && typeof terminationReason === "string") {
+      const reasonColor = isCanceled ? chalk6.yellow : chalk6.red;
+      console.log(reasonColor(`    Termination: ${terminationReason}`));
+    }
+    if (isFusion) {
+      const contribution = formatFusionFallbackContribution(candidateRecord.success).replace(
+        /_/g,
+        " "
+      );
+      console.log(chalk6.gray(`    Contribution: ${contribution}`));
+    } else {
+      console.log(chalk6.gray(`    Completeness: ${completeness}`));
+    }
+    const testVerificationLine = formatVariantTestVerificationLine(candidateRecord);
+    if (testVerificationLine) {
+      const testColor = testVerificationLine.endsWith("passed") ? chalk6.green : testVerificationLine.endsWith("failed") ? chalk6.red : chalk6.yellow;
+      console.log(testColor(`    ${testVerificationLine}`));
+    }
+    printCandidateEvidenceLines(candidateRecord);
+    const undeliveredLine = options.undeliveredLineFor?.(variantLabel);
+    if (undeliveredLine) console.log(chalk6.gray(`    ${undeliveredLine}`));
+    const inputSpecWarning = normaliseInputSpecWarning(candidateRecord.inputSpecWarning);
+    if (inputSpecWarning?.hasFillPlaceholders) {
+      const missingFields = inputSpecWarning.missingFields && inputSpecWarning.missingFields.length > 0 ? `; missing: ${inputSpecWarning.missingFields.join(", ")}` : "";
+      console.log(
+        chalk6.yellow(
+          `    Input spec warning: incomplete (${typeof inputSpecWarning.completenessScore === "number" ? `${Math.round(inputSpecWarning.completenessScore * 100)}%` : "unknown"}${missingFields})`
+        )
+      );
+    }
+    console.log(chalk6.gray(`    Duration: ${duration}`));
+    console.log(chalk6.gray(`    ${prInfo}`));
+    const partialStats = extractPartialEditStats(candidateRecord);
+    if (isTimedOut && (candidateRecord.partialEdits === true || partialStats)) {
+      console.log(
+        chalk6.yellow(
+          `    Partial edits: ${partialStats?.filesChanged ?? 0} files, +${partialStats?.linesAdded ?? 0}/-${partialStats?.linesRemoved ?? 0}`
+        )
+      );
+    }
+    if (typeof candidateRecord.errorMessage === "string") {
+      console.log(chalk6.gray(`    Error: ${candidateRecord.errorMessage}`));
+    }
+    console.log();
+  }
+}
+
+export {
+  resolveCompetitionStatusFromCompetitionState,
+  competitionStatusStateFromBasicResult,
+  resolveDefaultCompetitionId,
+  secondaryJudgePicks,
+  getLatestMultiJudgeRunForTask,
+  renderMultiJudgeRun,
+  resolveCompetitionResultsTaskId,
+  formatJudgeEvaluationModelLine,
+  readLatestProfileMatrixSummary,
+  resolveWarningVerbosity,
+  getDisplayableSelfConfidence,
+  formatProviderExecutionPathLine,
+  candidateHasFailingVerificationForDisplay,
+  shouldRenderUnretainedJudgeTopPick,
+  formatVariantTestVerificationLine,
+  formatDonorDecisionDiagnostics,
+  summarizeDonorSelectionDecisions,
+  summarizeSynthesisArtifact,
+  formatSynthesisTelemetrySummaryLines,
+  formatDonorMaterialSummaryLine,
+  buildSynthesisResultsJson,
+  buildFusionSynthesisResultsJson,
+  createCompeteResultsCommand,
+  renderFallbackResults
+};
+//# sourceMappingURL=chunk-762ACDZJ.js.map