@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-CKP2Q3TP.js

@@ -0,0 +1,1905 @@
+import {
+  anonymizeVariants,
+  buildDeterministicPreScoreGateSection,
+  buildVariantDeliverableExcerptForJudge,
+  buildVariantEvidenceCandidatesForJudge,
+  checkRankingScoreConsistency,
+  computeDeterministicPreScoreGateContext,
+  computePromptOrderEvidenceCandidateLimit,
+  computeSelfConsistencyWarning,
+  createFallbackAnonymizationSeed,
+  createPercentScore,
+  deAnonymizeRationale,
+  detectDuplicateContent,
+  getDefaultJudgeModel,
+  normalizeRankingIds,
+  observeVariantHealth,
+  persistJudgeFailureArtifact,
+  resolveAnonymizationRunId,
+  selectDeterministicWinnerFromScores,
+  shouldAnonymize,
+  validateRanking
+} from "./chunk-TSPQONRT.js";
+import {
+  charsToTokens
+} from "./chunk-LFTQVYBB.js";
+import {
+  THREE_BUCKET_RUBRIC_FORMULA_TEXT,
+  computeFinalScore
+} from "./chunk-73NCTWKL.js";
+import {
+  collectJsonCandidates,
+  isStandaloneMalformedJsonCandidate,
+  parseJsonCandidate
+} from "./chunk-VVGEPBPS.js";
+import {
+  buildVariantFileInventory
+} from "./chunk-E74LUIID.js";
+import {
+  formatVerificationProvenanceForPrompt,
+  resolveJudgeEvaluationContext
+} from "./chunk-66AGFTBQ.js";
+import {
+  extractChangedFilesMeta
+} from "./chunk-CFBIG37O.js";
+import {
+  resolveTaskType
+} from "./chunk-W4OMESPG.js";
+import {
+  detectExplicitReviewTask,
+  parsePromptSpec
+} from "./chunk-X6UIEADS.js";
+import {
+  LlmJudgeExecutor
+} from "./chunk-5REDMNLZ.js";
+import {
+  mergeTokenUsage,
+  sumTokenUsage
+} from "./chunk-7DNSNKJV.js";
+import {
+  extractDiffText,
+  frameUntrustedJudgeTaskText
+} from "./chunk-IATQ7NBI.js";
+import {
+  JUDGE_FEATURE_FLAGS
+} from "./chunk-BSE4R6XD.js";
+
+// src/core/judge/ai-judge-prompt.ts
+function buildDefaultPromptText() {
+  const emptyArrayInstruction = JUDGE_FEATURE_FLAGS.RATIONALE_EMPTY_ARRAYS === "on" ? "\n15. If a variant has no genuine strengths, weaknesses, or evidence for a dimension, use an empty array [] rather than inventing items." : "";
+  return `You are an impartial judge evaluating submissions for a task.
+The task may involve software, design, writing, research, planning, or other knowledge work.
+
+## Task
+{task_prompt}
+
+## Task Profile Guidance
+{task_profile_guidance}
+
+## Submissions
+{variant_sections}
+
+## Evaluation Criteria
+
+Rate each submission on three dimensions:
+
+**Delivery (50%)**: Did the submission produce the requested deliverable?
+- 90-100: All requirements met, task fully completed
+- 70-89: Most requirements met, minor gaps
+- 50-69: Partial completion, meaningful gaps
+- 30-49: Minimal delivery, major gaps
+- 0-29: Failed or no meaningful output
+If the task requests implementation and a submission only describes an approach without producing the deliverable, treat that as important delivery evidence; do not apply a fixed host-side cap. For tasks classified as analysis/planning/design in the Task Profile Guidance, a well-structured analysis IS the deliverable.
+If the task explicitly calls for a minimal or tiny change (e.g., a single comment/doc/typo fix), unnecessary extra scope (new files/APIs or unrelated changes) should reduce the Delivery score.
+When the task requires listing the exact resources that would be affected (branch names, paths, PIDs, file lists, identifiers), placeholder or generated identifiers do not satisfy the requirement. Examples of fabrication: identifiers built from a template expression combining a fixed prefix with a loop index, synthetic indices generated by Array.from or similar, or literal placeholder strings (such as fake paths or fake resource names). Treat fabricated identifiers as a delivery defect, not a cosmetic one.
+
+**Correctness (30%)**: Is the work likely correct?
+- 90-100: High confidence in correctness, edge cases addressed
+- 70-89: Good correctness, minor concerns
+- 50-69: Some correctness risks
+- 30-49: Significant risks or errors
+- 0-29: Fundamental errors
+For CLI, configuration, or API behavior tasks: named flags, options, or parameters must be traced from declaration through parsing into the handler that is supposed to read them. A flag that is declared but never read by the code path it is supposed to gate is a correctness defect, not a documentation issue, even when the variant's tests pass against mocks.
+
+**Quality (20%)**: Is the work clear, well-structured, and appropriate for its domain?
+- 90-100: Excellent structure and clarity
+- 70-89: Good quality, minor issues
+- 50-69: Acceptable, some concerns
+- 30-49: Notable quality problems
+- 0-29: Poor quality
+
+## Evidence Calibration
+
+Distinguish between proxy evidence and outcome evidence.
+- Proxy evidence: naming alignment, documentation updates, keyword matches, structural resemblance to the requested change.
+- Outcome evidence: direct proof that the requested result was achieved \u2014 behavior changed, failing condition removed, verification passed.
+
+Outcome evidence is stronger than proxy evidence. Multiple corroborating proxies can still be jointly wrong when none directly measures the requested outcome. Do not treat documentation quality or requirement-word overlap as proof that the task outcome was achieved. When two variants achieve the same outcome, proxy evidence may still differentiate quality.
+When the task explicitly names representative commands, operations, or target flows, structural changes alone are still only proxy evidence. If direct evidence for those named targets is missing, contradictory, or only implied, state that gap explicitly in the rationale and keep confidence below strong-certainty levels.
+Mocked tests are proxy evidence, not outcome evidence. A test that mocks the module under inspection is proxy evidence for that module's runtime behavior, regardless of assertion count or quality. Outcome evidence requires real execution signals (gate results, logs, stdout), verified integration behavior, or direct unmocked code-path proof. Do not upgrade proxy to outcome because of test count, naming overlap, or structural match.
+When task-appropriate deterministic verification passes and the evidence shows the requested requirements implemented, do not invent a weakness from excerpt visibility alone (for example, "not explicitly visible in diff excerpt"). Penalize only concrete task-relevant defects, unmet requirements, contradictory evidence, or real verification gaps.
+
+## Instructions
+
+1. For each submission, identify specific evidence from the deliverable excerpt.
+   Cite evidence using E1, E2, etc. from the evidence candidates.
+2. Assess each criterion against the evidence you identified.
+3. Derive scores from your assessment. The score should follow from the evidence, not precede it.
+4. Judge by the task's actual domain. For non-technical tasks, do not apply software-centric assumptions.
+5. Submission order is arbitrary -- do not let presentation order influence scores.
+6. Length is not quality. Score substance, not volume. Keep each criterion rationale to 1-2 sentences. Evidence arrays: cite at most 3 IDs per criterion. Summary rationale and rankingRationale: 3 sentences maximum; cite at least one evidence ID (E1, E2...) or file path when available. Brevity prevents response truncation.
+7. If evaluating a single submission, score on absolute merit. Do not inflate scores due to lack of competition. Similarly, do not inflate confidence: for single-variant evaluations, confidence reflects quality assessment certainty (how certain you are the scores are accurate), NOT winner selection certainty (which is trivially 1.0 and must not be reported as the confidence value). When the sole submission produced no output (empty diff) or all dimension scores are near zero (\u2264 10), confidence MUST be \u2264 0.40 \u2014 there is insufficient evidence to assess quality meaningfully.
+8. Provide confidence (0.0-1.0) in the score ranking:
+   - 0.95+: Unambiguous winner, nearly any evaluator would agree
+   - 0.85-0.94: Strong direct evidence supports the winner (e.g., deliverables produced vs none, on-task vs off-task, core feature functional vs non-functional, required targets directly covered); minor residual uncertainty
+   - 0.70-0.84: Clear lean toward winner; evidence supports the ranking but some dimensions are close
+   - 0.50-0.69: Meaningful uncertainty; winner is plausible but alternative ranking defensible
+   - 0.30-0.49: Close call or insufficient evidence
+   - Below 0.30: Single-variant with no output or zero scores \u2014 quality cannot be assessed
+   When direct outcome evidence is decisive (deliverables produced vs none, on-task vs off-task, passing tests vs failing, core feature functional vs non-functional), confidence should be at least 0.85 even if individual evidence excerpts are thin. Do not apply that high-confidence floor when the task names specific commands or operations and the evidence remains only structural or proxy-level for those targets.
+9. Score calibration:
+   - Reserve 100 for cases with no material weaknesses found from evidence.
+   - Use 95+ only when evidence quality is high and no unresolved must-level gaps are visible.
+10. For each variant, include one concrete limitation/trade-off with evidence.
+   If none are found, explicitly state "No material weakness found from available evidence."
+11. Confidence rationale must reference evidence quality and residual uncertainty.
+12. Include a top-2 separation rationale explaining why the top-scoring variant beat runner-up.
+   For single-variant evaluation, set top-2 rationale to "N/A: single variant".
+13. Declare the winner in the top-level winner object when comparing multiple variants. If no variant should win, return \`"winner": null\` and explain why in \`summary.rankingRationale\`. An explicit null is authoritative; summary.ranking remains ordered comparative context and is the fallback only when winner is omitted or invalid.
+14. Rank all variants from best to worst in summary.ranking.
+15. For multi-variant evaluations, compute os (overallScore) per variant as: ${THREE_BUCKET_RUBRIC_FORMULA_TEXT}. summary.ranking MUST normally be sorted by os descending. When a variant has a decisive correctness failure (e.g., failing tests, broken build, fundamental logic errors, inaccurate findings with line-citation discrepancies), reflect that failure clearly in the correctness score so that the os ranking captures the quality difference. Explain in rankingRationale when a correctness failure is the deciding factor.${emptyArrayInstruction}
+16. Include the optional dimensions block for every variant. Use independent 0-100 scores for readability, maintainability, security, and innovation. Do not copy the same number into every field unless the evidence genuinely supports identical scores.
+
+Respond with ONLY the following JSON structure. First character must be '{'. No prose, no markdown fences, no explanatory text.
+All "score" fields, the "dimensions" values, and "os" are integers 0-100; "confidence" is between 0.0 and 1.0. The example values below are illustrative \u2014 replace them with your real assessment:
+{
+  "variants": [
+    {
+      "id": "variant-id",
+      "delivery": { "score": 82, "rationale": "...", "evidence": ["E1"] },
+      "correctness": { "score": 76, "rationale": "...", "evidence": ["E2"] },
+      "quality": { "score": 71, "rationale": "...", "evidence": [] },
+      "dimensions": {
+        "readability": 74,
+        "maintainability": 70,
+        "security": 66,
+        "innovation": 62
+      },
+      "limitation": { "summary": "...", "evidence": ["E3"] },
+      "os": 79
+    }
+  ],
+  "summary": {
+    "ranking": ["variant-best", "variant-worst"],
+    "rankingRationale": "...",
+    "confidence": 0.85,
+    "confidenceRationale": "...",
+    "top2SeparationRationale": "..."
+  },
+  "winner": {
+    "id": "variant-best",
+    "reason": "..."
+  }
+}
+For a judge-authored no-winner decision, replace the winner object with \`"winner": null\`; still include every variant in summary.ranking.`;
+}
+var DEFAULT_AI_JUDGE_PROMPT = buildDefaultPromptText();
+function buildTaskProfileGuidance(context) {
+  const base = `Task profile: ${context.taskType} (detected confidence: ${context.confidence}). This profile is prompt-only context and must not be treated as a deterministic scoring rule.`;
+  if (context.taskType === "code") {
+    return `${base}
+- Prioritize direct evidence of requirements coverage and likely behavior.
+- Use execution-related evidence when present.
+- Do not infer lower quality from missing execution evidence unless execution was explicitly requested.`;
+  }
+  if (context.limitedEmpiricalSignals) {
+    return `${base}
+Limited empirical signals are available for this task type.
+- Weight deliverable content and explicit requirements coverage heavily.
+- Do not infer lower quality from missing execution-specific signals.
+- Prefer concrete, checkable claims over speculative assertions.`;
+  }
+  return `${base}
+- Weight deliverable content and explicit requirements coverage heavily.
+- Prefer concrete, checkable claims over speculative assertions.`;
+}
+function buildDomainSignalSemanticsBlock(context) {
+  const combined = `${context.taskPrompt}
+${context.variantSections}`;
+  if (!/\b(?:synthesisApplied|winnerFallback|aiGuidedFallbackAttempted|aiGuidedFallbackOutcome|actualStrategy|aiFirstActualStrategy|donor_augmented|winner_equivalent|candidate_rejected|generation_failed)\b/.test(
+    combined
+  )) {
+    return null;
+  }
+  return `## Relevant Existing Signal Semantics
+
+The task/submissions reference existing synthesis visibility signals. Treat these as factual context for interpretation:
+- \`synthesisApplied=true\` means a synthesized result was applied; it does not by itself prove donor material survived.
+- \`winnerFallback=true\` means the declared winner was retained.
+- \`aiGuidedFallbackOutcome=donor_augmented\` means agentic inspection retained donor material.
+- \`aiGuidedFallbackOutcome=winner_equivalent\` means agentic inspection found no useful donor delta and retained the winner.
+- \`aiGuidedFallbackOutcome=generation_failed\` or \`candidate_rejected\` means fallback followed generation, apply, or gate failure.
+- \`actualStrategy\` / \`aiFirstActualStrategy\` describe the actual path used by agentic synthesis: agentic-synthesis, cherry-pick, or winner-only.
+
+Use these semantics only when judging claims about these fields. They are contextual evidence, not scoring caps.`;
+}
+function buildAIJudgePrompt(context, customPrompt) {
+  const template = customPrompt ?? DEFAULT_AI_JUDGE_PROMPT;
+  const safeTaskPrompt = frameUntrustedJudgeTaskText(context.taskPrompt ?? "");
+  const guidance = context.taskProfileGuidance?.trim() || "No additional task profile guidance.";
+  const templatePlaceholderProbe = template.replace(/\{task_prompt\}/g, "__TASK_PROMPT__").replace(/\{variant_sections\}/g, "__VARIANT_SECTIONS__").replace(/\{task_profile_guidance\}/g, "__TASK_PROFILE_GUIDANCE__").replace(/\{evaluation_guidance\}/g, "__TASK_PROFILE_GUIDANCE__");
+  const unreplacedTemplateTokens = templatePlaceholderProbe.match(/\{[a-z_]+\}/g);
+  if (unreplacedTemplateTokens) {
+    throw new Error(
+      `AIJudgePrompt: unreplaced placeholder tokens in prompt: ${unreplacedTemplateTokens.join(", ")}`
+    );
+  }
+  const hadPlaceholder = template.includes("{task_profile_guidance}") || template.includes("{evaluation_guidance}");
+  let result = template.replace(/\{task_prompt\}/g, safeTaskPrompt).replace(/\{variant_sections\}/g, context.variantSections).replace(/\{task_profile_guidance\}/g, guidance).replace(/\{evaluation_guidance\}/g, guidance);
+  if (!hadPlaceholder && context.taskProfileGuidance) {
+    result = `${result}
+
+## Task Profile Guidance
+${guidance}`;
+  }
+  if (context.judgeProfile) {
+    const profileBlock = buildJudgeProfileBlock(context.judgeProfile);
+    if (profileBlock) {
+      result = `${result}
+
+${profileBlock}`;
+    }
+  }
+  const semanticsBlock = buildDomainSignalSemanticsBlock(context);
+  if (semanticsBlock) {
+    result = `${result}
+
+${semanticsBlock}`;
+  }
+  return result;
+}
+function buildJudgeProfileBlock(profile) {
+  if (profile === "best-as-delivered") {
+    return `## Judge Profile: BEST AS DELIVERED
+
+Declare the best complete deliverable as submitted.
+Evaluate what was ACTUALLY delivered, not what COULD be delivered with follow-up work.
+Penalize unrelated artifact churn, unmanaged/generated/state artifacts, missing integration points,
+incomplete requested verification or presentation wiring, and cleanup required before accepting.
+Do not give credit for unrealized potential that requires additional work to realize.`;
+  }
+  if (profile === "acceptance-ready") {
+    return `## Judge Profile: ACCEPTANCE READY
+
+Declare the winner that can be accepted now with the least unresolved risk.
+Treat passing task-appropriate verification as strong evidence of acceptance readiness.
+Treat failing or missing required verification signals as major acceptance risk.
+Do not select a failing variant over a passing variant unless all passing variants are materially incomplete or unsafe, and explain why.`;
+  }
+  if (profile === "best-foundation") {
+    return `## Judge Profile: BEST FOUNDATION
+
+Declare the winner that is the best base for a follow-up repair or synthesis pass.
+Do not ignore failing verification \u2014 classify the apparent follow-up cost (mechanical, localized, moderate, structural).
+A failing variant may beat a passing variant only when its underlying approach, requirement coverage, and locality make total acceptance effort lower than starting from the passing candidate.`;
+  }
+  return "";
+}
+function formatVariantSection(variantId, variantName, evidenceList, deliverableExcerpt, deterministicPreScoreGates) {
+  const lines = [];
+  lines.push(`### Variant: ${variantName} (id: ${variantId})`);
+  lines.push("");
+  if (typeof deterministicPreScoreGates === "string" && deterministicPreScoreGates.trim().length > 0) {
+    lines.push("**Deterministic Pre-Score Gates**:");
+    lines.push(deterministicPreScoreGates.trim());
+    lines.push("");
+  }
+  const promptOrderMode = JUDGE_FEATURE_FLAGS.JUDGE_PROFILE;
+  if (promptOrderMode === "stable" || promptOrderMode === "shadow" || promptOrderMode === "experimental") {
+    lines.push("**Deliverable Excerpt**:");
+    lines.push(deliverableExcerpt);
+    lines.push("");
+    if (evidenceList.length > 0) {
+      lines.push("**Evidence Candidates** (cite as E1, E2, etc.):");
+      evidenceList.forEach((evidence, index) => {
+        lines.push(`E${index + 1}: ${evidence}`);
+      });
+      lines.push("");
+    }
+  } else {
+    if (evidenceList.length > 0) {
+      lines.push("**Evidence Candidates** (cite as E1, E2, etc.):");
+      evidenceList.forEach((evidence, index) => {
+        lines.push(`E${index + 1}: ${evidence}`);
+      });
+      lines.push("");
+    }
+    lines.push("**Deliverable Excerpt**:");
+    lines.push(deliverableExcerpt);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function validateAIJudgeOutput(output) {
+  if (!output || typeof output !== "object") {
+    return false;
+  }
+  const root = output;
+  if (!Array.isArray(root.variants) || root.variants.length === 0) {
+    return false;
+  }
+  for (const variant of root.variants) {
+    if (!validateVariantEntry(variant)) {
+      return false;
+    }
+  }
+  if (root.variants.length > 1) {
+    for (const variant of root.variants) {
+      const v = variant;
+      if (v.os === void 0) return false;
+    }
+    const summary = root.summary;
+    if (!summary || !Array.isArray(summary?.ranking) || summary.ranking.length === 0) {
+      return false;
+    }
+  }
+  if (!validateSummaryEntry(root.summary)) {
+    return false;
+  }
+  if (root.ranking !== void 0 && !validateRankingArray(root.ranking)) {
+    return false;
+  }
+  if (!validateWinnerEntry(root.winner)) {
+    return false;
+  }
+  return true;
+}
+function validateVariantEntry(variant) {
+  if (!variant || typeof variant !== "object") {
+    return false;
+  }
+  const v = variant;
+  if (typeof v.id !== "string" || v.id.length === 0) {
+    return false;
+  }
+  if (!validateBucketEntry(v.delivery)) {
+    return false;
+  }
+  if (!validateBucketEntry(v.correctness)) {
+    return false;
+  }
+  if (!validateBucketEntry(v.quality)) {
+    return false;
+  }
+  if (!validateLimitationEntry(v.limitation)) {
+    return false;
+  }
+  if (!validateDimensionsEntry(v.dimensions)) {
+    return false;
+  }
+  if (v.os !== void 0) {
+    if (typeof v.os !== "number" || !Number.isFinite(v.os) || v.os < 0 || v.os > 100) {
+      return false;
+    }
+  }
+  return true;
+}
+function validateBucketEntry(bucket) {
+  if (!bucket || typeof bucket !== "object") {
+    return false;
+  }
+  const b = bucket;
+  if (typeof b.score !== "number" || !Number.isFinite(b.score) || b.score < 0 || b.score > 100) {
+    return false;
+  }
+  if (typeof b.rationale !== "string") {
+    return false;
+  }
+  if (!Array.isArray(b.evidence)) {
+    return false;
+  }
+  const allowEmptyArrays = JUDGE_FEATURE_FLAGS.RATIONALE_EMPTY_ARRAYS === "on";
+  if (!allowEmptyArrays && b.evidence.length === 0) {
+    return false;
+  }
+  for (const e of b.evidence) {
+    if (typeof e !== "string") {
+      return false;
+    }
+  }
+  return true;
+}
+function validateDimensionsEntry(dimensions) {
+  if (dimensions === void 0) {
+    return true;
+  }
+  if (!dimensions || typeof dimensions !== "object") {
+    return false;
+  }
+  const d = dimensions;
+  const allowedKeys = ["readability", "maintainability", "security", "innovation"];
+  for (const [key, value] of Object.entries(d)) {
+    if (!allowedKeys.includes(key)) {
+      return false;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 100) {
+      return false;
+    }
+  }
+  return true;
+}
+function validateSummaryEntry(summary) {
+  if (summary === void 0) {
+    return true;
+  }
+  if (!summary || typeof summary !== "object") {
+    return false;
+  }
+  const s = summary;
+  if (s.ranking !== void 0 && !validateRankingArray(s.ranking)) {
+    return false;
+  }
+  if (s.rankingRationale !== void 0 && typeof s.rankingRationale !== "string") {
+    return false;
+  }
+  if (s.confidence !== void 0) {
+    if (typeof s.confidence !== "number" || !Number.isFinite(s.confidence) || s.confidence < 0 || s.confidence > 1) {
+      return false;
+    }
+  }
+  if (s.confidenceRationale !== void 0 && typeof s.confidenceRationale !== "string") {
+    return false;
+  }
+  if (s.top2SeparationRationale !== void 0 && typeof s.top2SeparationRationale !== "string") {
+    return false;
+  }
+  return true;
+}
+function validateWinnerEntry(winner) {
+  if (winner === void 0) {
+    return true;
+  }
+  if (winner === null) {
+    return true;
+  }
+  if (typeof winner !== "object") {
+    return false;
+  }
+  const w = winner;
+  const winnerId = typeof w.id === "string" && w.id.trim().length > 0 ? w.id.trim() : typeof w.variant === "string" && w.variant.trim().length > 0 ? w.variant.trim() : "";
+  if (winnerId.length === 0) {
+    return false;
+  }
+  if (w.reason !== void 0 && typeof w.reason !== "string") {
+    return false;
+  }
+  if (w.confidence !== void 0) {
+    if (typeof w.confidence !== "number" || w.confidence < 0 || w.confidence > 1) {
+      return false;
+    }
+  }
+  if (w.confidenceRationale !== void 0 && typeof w.confidenceRationale !== "string") {
+    return false;
+  }
+  if (w.top2SeparationRationale !== void 0 && typeof w.top2SeparationRationale !== "string") {
+    return false;
+  }
+  return true;
+}
+function validateRankingArray(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    return false;
+  }
+  const normalized = value.map((entry) => typeof entry === "string" ? entry.trim() : "");
+  if (normalized.some((entry) => entry.length === 0)) {
+    return false;
+  }
+  return new Set(normalized).size === normalized.length;
+}
+function validateLimitationEntry(limitation) {
+  if (limitation === void 0) {
+    return true;
+  }
+  if (!limitation || typeof limitation !== "object") {
+    return false;
+  }
+  const value = limitation;
+  if (typeof value.summary !== "string") {
+    return false;
+  }
+  if (!Array.isArray(value.evidence)) {
+    return false;
+  }
+  for (const entry of value.evidence) {
+    if (typeof entry !== "string") {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/core/judge/deliverable-gating.ts
+function extractArtifactEvidence(variant) {
+  const filesChanged = variant.filesChanged ?? variant.gitMetrics?.filesChanged ?? variant.worktreeSummary?.filesChanged ?? variant.worktreeSummary?.statusLines?.length ?? 0;
+  const workspaceEditsApplied = variant.workspaceEditsApplied ?? 0;
+  const emptyChanges = variant.emptyChanges ?? false;
+  const hasEvidence = filesChanged > 0 && !emptyChanges || workspaceEditsApplied > 0;
+  return {
+    filesChanged,
+    workspaceEditsApplied,
+    emptyChanges,
+    hasEvidence
+  };
+}
+function extractDeliverableContract(enhancementSet) {
+  if (!enhancementSet) {
+    return {
+      requiresArtifact: false,
+      artifactRequiredCriteria: [],
+      hasConflict: false
+    };
+  }
+  const contractIntent = enhancementSet.intent?.category;
+  const acceptanceCriteria = enhancementSet.acceptanceCriteria ?? [];
+  const artifactRequiredCriteria = acceptanceCriteria.filter((criterion) => {
+    const verification = criterion.verification;
+    if (!verification || typeof verification !== "object") return false;
+    return verification.requiresArtifact === true;
+  }).map((criterion) => criterion.id || criterion.description);
+  const requiresArtifact = artifactRequiredCriteria.length > 0;
+  const hasConflict = requiresArtifact && contractIntent === "analyze";
+  return {
+    requiresArtifact,
+    contractIntent,
+    artifactRequiredCriteria,
+    hasConflict
+  };
+}
+function checkVariantCompliance(variant, contract) {
+  const evidence = extractArtifactEvidence(variant);
+  const codes = [];
+  if (!contract.requiresArtifact) {
+    return {
+      variantId: variant.variant,
+      isCompliant: true,
+      evidence,
+      codes
+    };
+  }
+  if (evidence.hasEvidence) {
+    codes.push("ARTIFACT_REQUIRED_MET");
+    return {
+      variantId: variant.variant,
+      isCompliant: true,
+      evidence,
+      codes
+    };
+  }
+  codes.push("ARTIFACT_REQUIRED_MISSING");
+  if (evidence.filesChanged > 0 && evidence.emptyChanges) {
+    codes.push("EMPTY_CHANGES_VIOLATION");
+  } else {
+    codes.push("NO_EVIDENCE_FOUND");
+  }
+  if (variant.executionIntent === "analysis" || variant.completenessScore?.category === "analysis") {
+    codes.push("VARIANT_LABEL_BYPASS");
+  }
+  if (contract.hasConflict) {
+    codes.push("ANALYSIS_INTENT_CONFLICT");
+  }
+  return {
+    variantId: variant.variant,
+    isCompliant: false,
+    evidence,
+    codes,
+    reason: `Missing required artifacts for criteria: ${contract.artifactRequiredCriteria.join(", ")}`
+  };
+}
+function filterByDeliverableCompliance(variants, enhancementSet, options = {}) {
+  const { skipManualVerification = true } = options;
+  void options.mode;
+  const contract = extractDeliverableContract(enhancementSet);
+  if (!contract.requiresArtifact) {
+    return {
+      filtered: variants,
+      compliance: variants.map((v) => checkVariantCompliance(v, contract)),
+      hadToRelax: false
+    };
+  }
+  if (skipManualVerification) {
+    const hasManualVerification = enhancementSet?.acceptanceCriteria?.some(
+      (criterion) => criterion.verification?.method === "manual"
+    );
+    if (hasManualVerification) {
+      return {
+        filtered: variants,
+        compliance: variants.map((v) => checkVariantCompliance(v, contract)),
+        hadToRelax: false,
+        warnings: ["Deliverable gating skipped: manual verification required"]
+      };
+    }
+  }
+  const compliance = variants.map((v) => checkVariantCompliance(v, contract));
+  const nonCompliantCount = compliance.filter((c) => !c.isCompliant).length;
+  const warnings = [];
+  if (nonCompliantCount > 0) {
+    warnings.push(
+      `${nonCompliantCount} variant(s) missing deliverable requirements: ${contract.artifactRequiredCriteria.join(", ")}`
+    );
+  }
+  if (contract.hasConflict) {
+    warnings.push('Contract conflict: intent is "analysis" but artifacts are required');
+  }
+  compliance.forEach((c) => {
+    if (!c.isCompliant) {
+      c.codes.push("SOFT_MODE_WARNING");
+    }
+  });
+  return {
+    filtered: variants,
+    compliance,
+    hadToRelax: warnings.length > 0,
+    ...warnings.length > 0 ? { warnings } : {}
+  };
+}
+function getComplianceTelemetry(compliance) {
+  const codes = {
+    ARTIFACT_REQUIRED_MET: 0,
+    ARTIFACT_REQUIRED_MISSING: 0,
+    ANALYSIS_INTENT_CONFLICT: 0,
+    EMPTY_CHANGES_VIOLATION: 0,
+    NO_EVIDENCE_FOUND: 0,
+    VARIANT_LABEL_BYPASS: 0,
+    SOFT_MODE_WARNING: 0,
+    HARD_MODE_FAILURE: 0
+  };
+  let compliantCount = 0;
+  let nonCompliantCount = 0;
+  for (const result of compliance) {
+    if (result.isCompliant) {
+      compliantCount++;
+    } else {
+      nonCompliantCount++;
+    }
+    for (const code of result.codes) {
+      codes[code]++;
+    }
+  }
+  return {
+    totalVariants: compliance.length,
+    compliantCount,
+    nonCompliantCount,
+    codes,
+    hadLabelBypass: codes.VARIANT_LABEL_BYPASS > 0,
+    hadConflict: codes.ANALYSIS_INTENT_CONFLICT > 0
+  };
+}
+
+// src/core/judge/judge-llm-call.ts
+async function executeWithSchemaRepair(args) {
+  const llmStart = Date.now();
+  let rawResponse;
+  let provider;
+  let model;
+  let thinkingBlocksObserved;
+  let tokenUsage;
+  let totalCostUsd;
+  let sandboxProvenance;
+  let sandboxEvidence;
+  try {
+    const result = await args.executor.evaluate(args.prompt, args.execOptions);
+    rawResponse = result.output;
+    provider = result.provider;
+    model = result.model;
+    thinkingBlocksObserved = result.thinkingBlocksObserved;
+    tokenUsage = result.tokenUsage;
+    totalCostUsd = result.totalCostUsd;
+    sandboxProvenance = result.sandboxProvenance;
+    sandboxEvidence = result.sandboxEvidence;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${args.errorPrefix}: Provider call failed - ${message}`);
+  }
+  let parsed = args.parse(rawResponse);
+  let schemaRepairRetry;
+  if (!parsed || !args.validate(parsed)) {
+    const invalidStandaloneJson = parsed ? args.isSuspectParse?.(rawResponse) ?? false : false;
+    if (!args.strict) {
+      const firstFailReason = !parsed || invalidStandaloneJson ? args.classifyFailure(rawResponse) : "schema_validation_failed";
+      schemaRepairRetry = {
+        attempted: true,
+        succeeded: false,
+        firstFailureReason: firstFailReason
+      };
+      args.persistArtifact(rawResponse, `${firstFailReason}_before_retry`);
+      args.onRetryWarn(firstFailReason);
+      const retryPrompt = args.prompt + args.formatReminder;
+      let retryResponse;
+      try {
+        const retryResult = await args.executor.evaluate(retryPrompt, args.execOptions);
+        retryResponse = retryResult.output;
+        provider = retryResult.provider;
+        model = retryResult.model;
+        thinkingBlocksObserved = retryResult.thinkingBlocksObserved;
+        tokenUsage = mergeTokenUsage(tokenUsage, retryResult.tokenUsage);
+        totalCostUsd = (totalCostUsd ?? 0) + (typeof retryResult.totalCostUsd === "number" ? retryResult.totalCostUsd : 0);
+        sandboxProvenance = retryResult.sandboxProvenance;
+        sandboxEvidence = retryResult.sandboxEvidence;
+      } catch (retryError) {
+        const message = retryError instanceof Error ? retryError.message : String(retryError);
+        throw new Error(`${args.errorPrefix}: Provider call failed on schema retry - ${message}`);
+      }
+      parsed = args.parse(retryResponse);
+      if (!parsed) {
+        const retryReason = args.classifyFailure(retryResponse);
+        args.persistArtifact(retryResponse, `${retryReason}_retry`);
+        throw new Error(
+          `${args.errorPrefix}: Output parse failure after retry [reason=${retryReason}] - ${args.createResponseSnippet(retryResponse)}`
+        );
+      }
+      if (!args.validate(parsed)) {
+        args.persistArtifact(retryResponse, "schema_validation_failed_retry");
+        const detail = args.describeValidationFailure(parsed);
+        throw new Error(
+          `${args.errorPrefix}: Output validation failure after retry [reason=schema_validation_failed]${detail ? ` - ${detail}` : ""}`
+        );
+      }
+      rawResponse = retryResponse;
+      schemaRepairRetry.succeeded = true;
+    } else {
+      if (!parsed || invalidStandaloneJson) {
+        const reason = args.classifyFailure(rawResponse);
+        args.persistArtifact(rawResponse, reason);
+        throw new Error(
+          `${args.errorPrefix}: Output parse failure [reason=${reason}] - ${args.createResponseSnippet(rawResponse)}`
+        );
+      }
+      args.persistArtifact(rawResponse, "schema_validation_failed");
+      const detail = args.describeValidationFailure(parsed);
+      throw new Error(
+        `${args.errorPrefix}: Output validation failure [reason=schema_validation_failed]${detail ? ` - ${detail}` : ""}`
+      );
+    }
+  }
+  const llmMs = Date.now() - llmStart;
+  return {
+    parsed,
+    rawResponse,
+    provider,
+    model,
+    thinkingBlocksObserved,
+    tokenUsage,
+    totalCostUsd,
+    sandboxProvenance,
+    sandboxEvidence,
+    schemaRepairRetry,
+    llmMs
+  };
+}
+
+// src/core/judge/judge-output-schema.ts
+function scoreParsedCandidate(parsed) {
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return 0;
+  }
+  const record = parsed;
+  let score = 0;
+  if (Array.isArray(record.variants)) score += 50;
+  if (record.winner != null) score += 20;
+  if (record.summary != null) score += 10;
+  if (typeof record.taskType === "string") score += 5;
+  if (Array.isArray(record.criteria)) score += 50;
+  if (typeof record.version === "string") score += 10;
+  if (typeof record.variantId === "string") score += 10;
+  if (typeof record.finalScore === "number") score += 15;
+  if (Array.isArray(record.blockingIssues)) score += 15;
+  if (typeof record.ranking === "number") score += 10;
+  return score;
+}
+function parseJudgeOutput(text) {
+  let bestParsed = null;
+  let bestScore = Number.NEGATIVE_INFINITY;
+  for (const candidate of collectJsonCandidates(text)) {
+    const parsed = parseJsonCandidate(candidate);
+    if (parsed === null) {
+      continue;
+    }
+    const score = scoreParsedCandidate(parsed);
+    if (score > bestScore) {
+      bestParsed = parsed;
+      bestScore = score;
+    }
+  }
+  return bestParsed;
+}
+
+// src/core/judge/ai-judge.ts
+var FILE_TARGET_COVERAGE_PROMPT_ITEM_LIMIT = 20;
+function estimateTokensFromChars(chars) {
+  return Math.max(0, charsToTokens(chars));
+}
+function makeMetric(chars) {
+  const c = Math.max(0, Math.floor(chars));
+  return { chars: c, estimatedTokens: estimateTokensFromChars(c) };
+}
+var AIJudge = class {
+  executor;
+  customPrompt;
+  provider;
+  /**
+   * Label-only default model (Claude judge_primary role). Used for telemetry/labels.
+   * NOT forwarded as the judge model unless explicitly set (see `explicitModel`) so the
+   * shared judge resolver can pick a model coherent with the resolved provider.
+   */
+  model;
+  /** Model explicitly provided at construction; undefined lets the resolver choose. */
+  explicitModel;
+  thinkingBudgetTokens;
+  requireThinking;
+  timeoutSeconds;
+  constructor(options = {}) {
+    this.executor = new LlmJudgeExecutor();
+    this.customPrompt = options.customPrompt;
+    this.provider = options.provider;
+    this.model = options.model ?? getDefaultJudgeModel();
+    this.explicitModel = options.model;
+    this.thinkingBudgetTokens = options.thinkingBudgetTokens;
+    this.requireThinking = options.requireThinking;
+    this.timeoutSeconds = options.timeoutSeconds ?? 300;
+  }
+  /**
+   * Evaluate variants using LLM-based judgment.
+   *
+   * @param variants - Array of variant results to evaluate
+   * @param prompt - Original task prompt
+   * @param options - Evaluation options
+   * @returns Judge synthesis result
+   */
+  async evaluate(variants, prompt, options = {}) {
+    const startTime = Date.now();
+    if (!variants || variants.length === 0) {
+      return this.createEmptyResult("No variants provided for evaluation", startTime);
+    }
+    let judgeVisibleVariants = variants;
+    let compliance;
+    let gatingWarnings;
+    if (options.enhancementSet) {
+      const gatingResult = filterByDeliverableCompliance(
+        variants,
+        options.enhancementSet,
+        { mode: "soft" }
+        // Use soft mode by default
+      );
+      compliance = gatingResult.compliance;
+      gatingWarnings = gatingResult.warnings;
+      judgeVisibleVariants = variants;
+    }
+    const evaluationContext = resolveJudgeEvaluationContext(prompt, {
+      evaluationContext: options.evaluationContext,
+      variants: judgeVisibleVariants
+    });
+    const promptTaskProfile = this.resolvePromptOnlyTaskProfile(prompt, evaluationContext);
+    const gatesStart = Date.now();
+    let preScoreGateContext;
+    try {
+      preScoreGateContext = await this.computePreScoreGateContext(
+        judgeVisibleVariants,
+        prompt,
+        options,
+        evaluationContext
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[AIJudge] Pre-score gate context computation failed: ${message}`);
+      preScoreGateContext = {
+        gateResultsByVariant: /* @__PURE__ */ new Map(),
+        structuralRisksByVariant: /* @__PURE__ */ new Map(),
+        gateSourceByVariant: /* @__PURE__ */ new Map(),
+        isCodeTask: false
+      };
+    }
+    const preScoreGatesMs = Date.now() - gatesStart;
+    const codeTaskGuidance = this.buildCodeTaskEvaluationGuidance(
+      prompt,
+      preScoreGateContext,
+      promptTaskProfile.taskType === "code" && promptTaskProfile.confidence !== "low"
+    );
+    const enrichedJudgeVisibleVariants = preScoreGateContext.enrichedVariants ?? judgeVisibleVariants;
+    const anonymizeEnabled = shouldAnonymize(
+      options
+    ) && enrichedJudgeVisibleVariants.length > 1;
+    let variantsForPrompt = enrichedJudgeVisibleVariants;
+    let anonymizationContext;
+    if (anonymizeEnabled) {
+      const runId = resolveAnonymizationRunId(options);
+      const taskIdSeed = typeof options.taskId === "string" && options.taskId.trim().length > 0 ? options.taskId.trim() : null;
+      const usedFallbackSeed = taskIdSeed === null;
+      const anonymizationResult = taskIdSeed ? anonymizeVariants(enrichedJudgeVisibleVariants, taskIdSeed, runId) : anonymizeVariants(
+        enrichedJudgeVisibleVariants,
+        createFallbackAnonymizationSeed(prompt, runId),
+        runId
+      );
+      variantsForPrompt = anonymizationResult.shuffledVariants;
+      anonymizationContext = {
+        result: anonymizationResult,
+        runId,
+        usedFallbackSeed
+      };
+    }
+    const resolveOriginalVariantId = (variantId) => anonymizationContext?.result.labelToVariant.get(variantId) ?? variantId;
+    const promptReviewDetection = detectExplicitReviewTask(prompt);
+    const variantHealth = observeVariantHealth({
+      variants: enrichedJudgeVisibleVariants,
+      judgeKind: "ai",
+      isExplicitReview: promptReviewDetection.isExplicitReview,
+      explicitReviewExemptsR5: true,
+      options,
+      taskId: options.taskId,
+      telemetry: options.telemetry,
+      resolveVariantId: resolveOriginalVariantId,
+      onWouldExclude: (variantId) => {
+        console.log(
+          `[AIJudge] R5 gate shadow: variant ${variantId} WOULD be skipped (no file changes, no test execution).`
+        );
+      }
+    });
+    let duplicateSignalGuidance = "";
+    if (JUDGE_FEATURE_FLAGS.DUPLICATE_CONTENT_SIGNAL !== "off") {
+      const duplicateSignals = variantsForPrompt.map((variant) => {
+        const scan = detectDuplicateContent(extractDiffText(variant) || variant.output || "");
+        return {
+          // This object also drives promptDelta telemetry, so record the identifier
+          // exactly as shown to the judge rather than leaking the original variant ID.
+          variant: anonymizationContext?.result.variantToLabel.get(variant.variant) ?? variant.variant,
+          hasDuplicates: scan.hasDuplicates,
+          duplicationRatio: scan.duplicationRatio,
+          duplicateBlockCount: scan.duplicateBlockCount
+        };
+      });
+      if (options.telemetry?.logShadowDelta && options.taskId?.trim()) {
+        options.telemetry.logShadowDelta({
+          tier: "prompt",
+          flag: "DUPLICATE_CONTENT_SIGNAL",
+          taskId: options.taskId.trim(),
+          applied: JUDGE_FEATURE_FLAGS.DUPLICATE_CONTENT_SIGNAL === "on",
+          addedInstructions: JUDGE_FEATURE_FLAGS.DUPLICATE_CONTENT_SIGNAL === "on" ? 1 : 0,
+          promptDelta: {
+            duplicateSignals
+          }
+        });
+      }
+      if (JUDGE_FEATURE_FLAGS.DUPLICATE_CONTENT_SIGNAL === "on") {
+        duplicateSignalGuidance = [
+          "Duplicate content signal (pre-LLM factual context):",
+          ...duplicateSignals.map((signal) => {
+            const ratioPercent = Math.round(signal.duplicationRatio * 1e3) / 10;
+            return `- ${signal.variant}: duplicationRatio=${ratioPercent}%, hasDuplicates=${signal.hasDuplicates}, duplicateBlocks=${signal.duplicateBlockCount}`;
+          }),
+          "Penalize unnecessary duplicated blocks that do not improve correctness or delivery."
+        ].join("\n");
+      }
+    }
+    const combinedGuidanceBase = codeTaskGuidance ? `${promptTaskProfile.guidance}
+
+${codeTaskGuidance}` : promptTaskProfile.guidance;
+    const combinedGuidance = duplicateSignalGuidance ? `${combinedGuidanceBase}
+
+${duplicateSignalGuidance}` : combinedGuidanceBase;
+    const {
+      context: promptContext,
+      evidenceMeta,
+      variantLabelMapping,
+      variantMeasurements
+    } = this.buildPromptContext(
+      variantsForPrompt,
+      prompt,
+      combinedGuidance,
+      preScoreGateContext,
+      anonymizationContext?.result.variantToLabel,
+      evaluationContext,
+      options.variantPaths
+    );
+    if (options.judgeProfile) {
+      promptContext.judgeProfile = options.judgeProfile;
+    }
+    const fullPrompt = buildAIJudgePrompt(promptContext, this.customPrompt);
+    const promptTelemetry = this.computeStandalonePromptTelemetry(
+      fullPrompt,
+      promptContext,
+      variantMeasurements
+    );
+    const callResult = await executeWithSchemaRepair({
+      executor: this.executor,
+      prompt: fullPrompt,
+      execOptions: {
+        provider: this.provider,
+        // Explicit model only (per-call override > constructor explicit); undefined lets
+        // the shared judge resolver pick a model coherent with the resolved provider for
+        // the 'ai' tier. Label/telemetry fall back to this.model elsewhere.
+        model: options.model ?? this.explicitModel,
+        judgeType: "ai",
+        timeoutSeconds: options.timeoutSeconds ?? this.timeoutSeconds,
+        maxAttempts: options.maxAttempts,
+        thinkingBudgetTokens: this.thinkingBudgetTokens,
+        requireThinking: this.requireThinking,
+        variantCount: variantsForPrompt.length,
+        env: options.env,
+        deadlineMs: options.deadlineMs,
+        abortSignal: options.abortSignal,
+        progressWriter: options.progressWriter,
+        progressLabel: options.progressLabel
+      },
+      parse: (raw) => this.repairMissingOverallScores(parseJudgeOutput(raw)),
+      validate: (value) => validateAIJudgeOutput(value),
+      formatReminder: "\n\nYour previous response was not valid JSON matching the required schema. Please respond with ONLY a valid JSON object matching the specified format.",
+      classifyFailure: (raw) => this.classifyParseFailureReason(raw),
+      isSuspectParse: (raw) => isStandaloneMalformedJsonCandidate(raw),
+      strict: options.maxAttempts === 1,
+      errorPrefix: "AIJudge",
+      persistArtifact: (response, label) => this.persistFailedResponse(response, options.taskId, label),
+      onRetryWarn: (reason) => {
+        console.warn(
+          `[AIJudge] Output parse/schema failure (reason=${reason}) \u2014 retrying once with format reminder`
+        );
+      },
+      createResponseSnippet: (response) => this.createResponseSnippet(response),
+      describeValidationFailure: (value) => this.describeValidationFailure(value)
+    });
+    const llmProvider = callResult.provider;
+    const llmModel = callResult.model;
+    const thinkingBlocksObserved = callResult.thinkingBlocksObserved;
+    const llmTokenUsage = callResult.tokenUsage;
+    const llmTotalCostUsd = callResult.totalCostUsd;
+    const llmSandboxProvenance = callResult.sandboxProvenance;
+    const llmSandboxEvidence = callResult.sandboxEvidence;
+    const schemaRepairRetry = callResult.schemaRepairRetry;
+    const llmMs = callResult.llmMs;
+    const parsedOutput = callResult.parsed;
+    const normalizedOutput = this.normalizeAnonymizedOutput(
+      parsedOutput,
+      anonymizationContext?.result.labelToVariant
+    );
+    const evidenceUsage = this.computeEvidenceUsageMetrics(
+      parsedOutput,
+      variantsForPrompt,
+      evidenceMeta
+    );
+    const agenticOutput = parsedOutput.agentic;
+    const synthesis = this.mapToSynthesisResult(
+      normalizedOutput,
+      variantsForPrompt,
+      startTime,
+      preScoreGateContext
+    );
+    if (synthesis.reasoning) {
+      const labelMapping = anonymizationContext?.result.labelToVariant ? Object.fromEntries(anonymizationContext.result.labelToVariant) : void 0;
+      synthesis.reasoning = deAnonymizeRationale(
+        synthesis.reasoning,
+        variantLabelMapping,
+        labelMapping
+      );
+    }
+    synthesis.variantHealth = variantHealth;
+    const audit = synthesis.metadata.audit ?? {};
+    const auditPayload = {
+      ...audit,
+      evidenceUsage,
+      promptTelemetry,
+      llmProvider: llmProvider ?? null,
+      thinkingBlocksObserved: thinkingBlocksObserved ?? null,
+      tokenUsage: llmTokenUsage ?? null,
+      aiTokensUsed: sumTokenUsage(llmTokenUsage) ?? null,
+      aiCostUsd: typeof llmTotalCostUsd === "number" ? llmTotalCostUsd : null,
+      sandboxProvenance: llmSandboxProvenance ?? null,
+      sandboxEvidence: llmSandboxEvidence ?? null,
+      routing: normalizedOutput.routing ?? null,
+      rankingConfidenceRationale: normalizedOutput.summary?.confidenceRationale ?? normalizedOutput.winner?.confidenceRationale ?? null,
+      top2SeparationRationale: normalizedOutput.summary?.top2SeparationRationale ?? normalizedOutput.winner?.top2SeparationRationale ?? null,
+      confidenceGrounding: {
+        confidenceRationalePresent: Boolean(
+          normalizedOutput.summary?.confidenceRationale?.trim() ?? normalizedOutput.winner?.confidenceRationale?.trim()
+        ),
+        top2SeparationPresent: Boolean(
+          normalizedOutput.summary?.top2SeparationRationale?.trim() ?? normalizedOutput.winner?.top2SeparationRationale?.trim()
+        )
+      },
+      variantLabelMapping,
+      taskProfile: {
+        taskType: promptTaskProfile.taskType,
+        confidence: promptTaskProfile.confidence,
+        source: promptTaskProfile.source,
+        limitedEmpiricalSignals: promptTaskProfile.limitedEmpiricalSignals,
+        reasoning: promptTaskProfile.reasoning ?? null
+      },
+      timingMs: {
+        preScoreGatesMs,
+        llmMs
+      },
+      schemaRepairRetry: schemaRepairRetry ?? {
+        attempted: false,
+        succeeded: false
+      }
+    };
+    if (anonymizationContext) {
+      auditPayload.anonymization = {
+        enabled: true,
+        judgeType: "ai",
+        seed: anonymizationContext.result.seed,
+        runId: anonymizationContext.runId ?? null,
+        usedFallbackSeed: anonymizationContext.usedFallbackSeed,
+        originalOrder: judgeVisibleVariants.map((variant) => variant.variant),
+        shuffledOrder: anonymizationContext.result.shuffledVariants.map(
+          (variant) => variant.variant
+        ),
+        labelsInOrder: variantsForPrompt.map(
+          (variant) => anonymizationContext.result.variantToLabel.get(variant.variant) ?? variant.variant
+        ),
+        variantIdMapping: variantsForPrompt.map((variant, index) => ({
+          id: `v${index + 1}`,
+          variant: variant.variant,
+          label: anonymizationContext.result.variantToLabel.get(variant.variant) ?? null
+        })),
+        labelToVariant: Object.fromEntries(anonymizationContext.result.labelToVariant)
+      };
+    }
+    if (agenticOutput !== void 0) {
+      auditPayload.agenticOutput = agenticOutput;
+    }
+    synthesis.metadata.audit = auditPayload;
+    if (llmModel) {
+      synthesis.metadata.model = llmModel;
+    }
+    if (compliance) {
+      const telemetry = getComplianceTelemetry(compliance);
+      const existingAudit = synthesis.metadata.audit ?? {};
+      synthesis.metadata.audit = {
+        ...existingAudit,
+        deliverableCompliance: telemetry,
+        gatingWarnings
+      };
+    }
+    this.validateFactualConsistency(
+      normalizedOutput,
+      variantsForPrompt,
+      preScoreGateContext,
+      synthesis
+    );
+    return synthesis;
+  }
+  async computePreScoreGateContext(variants, taskPrompt, options, evaluationContext) {
+    let resolution = evaluationContext?.taskTypeResolution;
+    if (!resolution) {
+      try {
+        const spec = parsePromptSpec(taskPrompt);
+        const changedFiles = Array.from(
+          new Set(
+            variants.flatMap((variant) => {
+              try {
+                return extractChangedFilesMeta(extractDiffText(variant)).map((meta) => meta.path);
+              } catch {
+                return [];
+              }
+            })
+          )
+        );
+        resolution = resolveTaskType(taskPrompt, {
+          fileTargets: spec.fileConstraint.targets,
+          changedFiles
+        });
+      } catch {
+        resolution = void 0;
+      }
+    }
+    return computeDeterministicPreScoreGateContext(
+      variants,
+      taskPrompt,
+      options,
+      "AIJudge",
+      resolution
+    );
+  }
+  buildArtifactScopeEvidenceSection(variant, fileConstraint) {
+    const inventory = buildVariantFileInventory(variant, { fileConstraint });
+    if (inventory.totalArtifactsChanged === 0) return void 0;
+    const lines = [
+      `Artifacts changed: ${inventory.totalArtifactsChanged}`,
+      `Scope hygiene risk: ${inventory.scopeHygieneRisk}`,
+      "Artifact list:",
+      ...inventory.artifactList.map((artifact) => `- ${artifact}`)
+    ];
+    const coverage = inventory.fileTargetCoverage;
+    if (coverage) {
+      lines.push(`FILE target coverage mode: ${coverage.mode}`);
+      lines.push(`FILE targets touched: ${coverage.touchedTargets.length}/${coverage.targetCount}`);
+      if (coverage.touchedTargets.length > 0) {
+        lines.push("Touched FILE targets:");
+        lines.push(...this.formatBoundedCoverageItems(coverage.touchedTargets));
+      }
+      if (coverage.missingTargets.length > 0) {
+        lines.push("Missing FILE targets:");
+        lines.push(...this.formatBoundedCoverageItems(coverage.missingTargets));
+      }
+      if (coverage.offTargetArtifacts.length > 0) {
+        lines.push("Off-target artifacts for hard FILE scope:");
+        lines.push(...this.formatBoundedCoverageItems(coverage.offTargetArtifacts));
+      }
+    }
+    if (inventory.suspiciousArtifacts.length > 0) {
+      lines.push("Suspicious/unmanaged/generated/state artifacts:");
+      lines.push(...inventory.suspiciousArtifacts.map((artifact) => `- ${artifact}`));
+    }
+    return lines.join("\n");
+  }
+  formatBoundedCoverageItems(items) {
+    const shown = items.slice(0, FILE_TARGET_COVERAGE_PROMPT_ITEM_LIMIT).map((item) => `- ${item}`);
+    const omitted = items.length - shown.length;
+    if (omitted > 0) {
+      shown.push(`- ... ${omitted} more`);
+    }
+    return shown;
+  }
+  buildDeterministicPreScoreGateSection(gateResults, structuralRisks, options) {
+    return buildDeterministicPreScoreGateSection(gateResults, structuralRisks, options);
+  }
+  normalizeAnonymizedOutput(output, labelToVariant) {
+    if (!labelToVariant || labelToVariant.size === 0) return output;
+    const normalizeVariantToken = (value) => {
+      if (typeof value !== "string") return value;
+      const trimmed = value.trim();
+      if (trimmed.length === 0) return value;
+      return labelToVariant.get(trimmed) ?? value;
+    };
+    return {
+      ...output,
+      variants: output.variants.map((variant) => ({
+        ...variant,
+        id: normalizeVariantToken(variant.id) ?? variant.id
+      })),
+      ranking: Array.isArray(output.ranking) ? output.ranking.map((entry) => normalizeVariantToken(entry) ?? entry) : output.ranking,
+      summary: output.summary ? {
+        ...output.summary,
+        ranking: Array.isArray(output.summary.ranking) ? output.summary.ranking.map((entry) => normalizeVariantToken(entry) ?? entry) : output.summary.ranking
+      } : output.summary,
+      winner: output.winner ? {
+        ...output.winner,
+        variant: typeof output.winner.variant === "string" ? normalizeVariantToken(output.winner.variant) ?? output.winner.variant : output.winner.variant,
+        id: typeof output.winner.id === "string" ? normalizeVariantToken(output.winner.id) ?? output.winner.id : output.winner.id
+      } : output.winner
+    };
+  }
+  /**
+   * Build the prompt context for AI evaluation.
+   */
+  buildPromptContext(variants, taskPrompt, taskProfileGuidance, preScoreGateContext, variantToLabel, evaluationContext, worktreePaths) {
+    const evidenceMeta = [];
+    const variantLabelMapping = {};
+    const variantMeasurements = {};
+    const promptSpec = parsePromptSpec(taskPrompt);
+    const sharedTaskType = evaluationContext?.taskTypeResolution.taskType;
+    const variantSections = variants.map((variant, index) => {
+      const promptVariantId = `v${index + 1}`;
+      variantLabelMapping[promptVariantId] = variant.variant;
+      const deliverableExcerpt = buildVariantDeliverableExcerptForJudge(variant).text;
+      const variantDisplayName = variantToLabel?.get(variant.variant) ?? variant.variant;
+      const promptOrderMode = JUDGE_FEATURE_FLAGS.JUDGE_PROFILE;
+      const evidenceList = buildVariantEvidenceCandidatesForJudge(variant, {
+        maxEvidenceCandidates: computePromptOrderEvidenceCandidateLimit(20, promptOrderMode)
+      });
+      evidenceMeta.push({
+        variantId: promptVariantId,
+        variantName: variantDisplayName,
+        evidenceCandidateCount: evidenceList.length
+      });
+      let section = formatVariantSection(
+        promptVariantId,
+        variantDisplayName,
+        evidenceList,
+        deliverableExcerpt
+      );
+      const verificationProvenance = formatVerificationProvenanceForPrompt(variant, {
+        worktreePath: worktreePaths?.[variant.variant]
+      });
+      if (verificationProvenance) {
+        section += `
+
+${verificationProvenance}`;
+      }
+      const artifactScopeEvidence = this.buildArtifactScopeEvidenceSection(
+        variant,
+        promptSpec.fileConstraint
+      );
+      if (artifactScopeEvidence) {
+        section += `
+
+### Artifact Scope Evidence
+${artifactScopeEvidence}`;
+      }
+      if (preScoreGateContext?.isCodeTask) {
+        const gateSource = preScoreGateContext.gateSourceByVariant?.get(variant.variant);
+        const gateSection = this.buildDeterministicPreScoreGateSection(
+          preScoreGateContext.gateResultsByVariant.get(variant.variant),
+          preScoreGateContext.structuralRisksByVariant.get(variant.variant),
+          { isCodeTask: true, gateSource }
+        );
+        if (gateSection) {
+          section += `
+
+### Pre-Score Gate Data
+${gateSection}`;
+        }
+      }
+      const evidenceSectionText = evidenceList.length > 0 ? [
+        "**Evidence Candidates** (cite as E1, E2, etc.):",
+        ...evidenceList.map((e, i) => `E${i + 1}: ${e}`),
+        ""
+      ].join("\n") : "";
+      variantMeasurements[variant.variant] = {
+        deliverableExcerptChars: deliverableExcerpt.length,
+        evidenceCandidatesChars: evidenceSectionText.length,
+        variantBlockChars: section.length
+      };
+      return section;
+    }).join("\n");
+    const taskTypeLine = sharedTaskType ? `**TASK TYPE**: ${sharedTaskType}` : "";
+    const guidanceWithTaskType = taskTypeLine ? `${taskTypeLine}
+
+${taskProfileGuidance}` : taskProfileGuidance;
+    return {
+      context: {
+        taskPrompt,
+        variantSections,
+        taskProfileGuidance: guidanceWithTaskType
+      },
+      evidenceMeta,
+      variantLabelMapping,
+      variantMeasurements
+    };
+  }
+  /**
+   * Compute prompt telemetry from the standalone AI judge prompt path.
+   *
+   * Measures section sizes in the already-built prompt without mutating it.
+   * Output shape is compatible with extractPromptTelemetrySummaryFromAudit().
+   */
+  computeStandalonePromptTelemetry(fullPrompt, context, variantMeasurements) {
+    const totalChars = fullPrompt.length;
+    const variantBlocksChars = context.variantSections.length;
+    const taskAndInstructionsChars = totalChars - variantBlocksChars;
+    let totalDiffChars = 0;
+    let totalEvidenceChars = 0;
+    const variants = {};
+    for (const [name, m] of Object.entries(variantMeasurements)) {
+      totalDiffChars += m.deliverableExcerptChars;
+      totalEvidenceChars += m.evidenceCandidatesChars;
+      variants[name] = {
+        deliverableExcerpt: makeMetric(m.deliverableExcerptChars),
+        evidenceCandidatesSection: makeMetric(m.evidenceCandidatesChars),
+        variantBlock: makeMetric(m.variantBlockChars)
+      };
+    }
+    const scaffoldingChars = totalChars - totalDiffChars - totalEvidenceChars;
+    return {
+      estimator: "chars_div_4",
+      path: "ai-judge-standalone",
+      variants,
+      sections: {
+        taskAndInstructions: makeMetric(taskAndInstructionsChars),
+        variantBlocks: makeMetric(variantBlocksChars),
+        diffContent: makeMetric(totalDiffChars),
+        evidenceCandidates: makeMetric(totalEvidenceChars),
+        scaffoldingTotal: makeMetric(scaffoldingChars),
+        totalPrompt: makeMetric(totalChars)
+      }
+    };
+  }
+  buildCodeTaskEvaluationGuidance(taskPrompt, preScoreGateContext, promptProfileAllowsCodeSignals) {
+    const requiresCanonicalAuthority = /\bcanonical\s+(?:behaviou?r|rules?|contract|semantics?|source|implementation)\b/i.test(
+      taskPrompt
+    );
+    const isCodeTask = preScoreGateContext?.isCodeTask === true || promptProfileAllowsCodeSignals;
+    if (!isCodeTask) return void 0;
+    const hasGateData = (preScoreGateContext?.gateResultsByVariant.size ?? 0) > 0;
+    const hasStructuralData = Array.from(
+      preScoreGateContext?.structuralRisksByVariant.values() ?? []
+    ).some((scan) => scan.findings.length > 0);
+    if (!hasGateData && !hasStructuralData && !requiresCanonicalAuthority) return void 0;
+    const lines = [];
+    lines.push("## Code-Task Correctness Checklist");
+    lines.push(
+      "- Check for self-referential function calls without a termination condition (infinite recursion risk)."
+    );
+    lines.push("- Check for referenced symbols that appear undefined or missing required imports.");
+    lines.push("- Check for return paths that conflict with stated/declared return behavior.");
+    lines.push("- Check for error handling paths that silently swallow exceptions.");
+    lines.push("- Check for obvious control-flow hazards (unreachable code, switch fallthrough).");
+    lines.push("");
+    lines.push("## Spec-Invariant & Public-Contract Check");
+    lines.push(
+      'Extract the explicit must/should requirements and public-contract guarantees the task states (e.g. "export the options type", "readonly results view", "validate before running", "stable ordering", "throw on invalid input"). For each variant that could affect the ranking, assess each requirement as implemented / partial / missing / unverified, citing evidence.'
+    );
+    lines.push(
+      `A passing test suite is not proof a stated invariant holds: a variant's own tests may never exercise the contract (e.g. never attempt to mutate a "readonly" view, never import the type that was supposed to be exported). Judge the contract from the implementation, not from test count.`
+    );
+    lines.push(
+      "Test count cuts both ways: a large test suite is not a strength when the variant's own gates are failing. When the per-variant gate data shows `buildGate.signal = fail`, `testGate.testStatus = failed` with executed tests, or new type errors, and `verificationStatus (adjusted, baseline-aware)` is neither `passed` nor `baseline_clean`, that is strong negative correctness evidence that a higher test quantity does not offset. (If adjusted verification is `baseline_clean`, treat the raw failure as pre-existing unless the diff proves otherwise.) On the strength of more tests alone, do not rank a variant whose gates fail this way above one whose gates pass; if you do, name the specific outcome evidence that overrides the gate failure."
+    );
+    lines.push(
+      "Treat omission of a spec-stated public contract (exported types, readonly/immutability boundaries, validation timing, ordering guarantees) as material evidence in its own right, and do not dismiss a required contract mechanism as unnecessary complexity solely because a simpler variant omits it. If you still rank a variant that omits the contract above one that implements it, explain why the contract is not actually required here or why other evidence outweighs it."
+    );
+    if (requiresCanonicalAuthority) {
+      lines.push("");
+      lines.push("## Canonical Authority Check");
+      lines.push("canonicalAuthority: required");
+      lines.push(
+        "Candidate-authored comments and tests are corroboration, not authority for what the canonical behavior requires. Ground the requirement in task-supplied or host-provided non-candidate evidence; if that authority is unavailable, mark the criterion unverified rather than accepting a candidate claim as its own proof."
+      );
+    }
+    return lines.join("\n");
+  }
+  computeEvidenceUsageMetrics(output, variants, evidenceMeta) {
+    const resolveEvidenceCandidateCount = (variantId) => {
+      const exact = evidenceMeta.find(
+        (m) => m.variantId === variantId || m.variantName === variantId
+      );
+      if (exact) return exact.evidenceCandidateCount;
+      const match = variantId.match(/^v(\d+)$/i);
+      if (match) {
+        const index = Number(match[1]);
+        if (Number.isFinite(index) && index >= 1 && index <= variants.length) {
+          const byIndex = evidenceMeta.find((m) => m.variantId === `v${index}`);
+          if (byIndex) return byIndex.evidenceCandidateCount;
+        }
+      }
+      return 0;
+    };
+    const candidates = evidenceMeta.map((m) => m.evidenceCandidateCount);
+    const evidenceCandidatesTotal = candidates.reduce((sum, n) => sum + n, 0);
+    const evidenceCandidatesMin = candidates.length > 0 ? Math.min(...candidates) : 0;
+    const evidenceCandidatesMax = candidates.length > 0 ? Math.max(...candidates) : 0;
+    const evidenceCandidatesAvg = candidates.length > 0 ? evidenceCandidatesTotal / candidates.length : 0;
+    const invalidSamples = [];
+    let bucketCount = 0;
+    let evidenceBucketsEmpty = 0;
+    let evidenceEntriesEid = 0;
+    let evidenceEntriesNonEid = 0;
+    let evidenceEidInvalid = 0;
+    for (const variant of output.variants) {
+      const evidenceCandidateCount = resolveEvidenceCandidateCount(variant.id);
+      const variantName = variants.find((v) => v.variant === variant.id)?.variant;
+      const buckets = [
+        { bucket: "delivery", evidence: variant.delivery.evidence },
+        { bucket: "correctness", evidence: variant.correctness.evidence },
+        { bucket: "quality", evidence: variant.quality.evidence }
+      ];
+      for (const { bucket, evidence } of buckets) {
+        bucketCount += 1;
+        if (evidence.length === 0) {
+          evidenceBucketsEmpty += 1;
+          continue;
+        }
+        for (const entry of evidence) {
+          const trimmed = entry.trim();
+          const eidMatch = trimmed.match(/^E(\d+)$/i);
+          if (!eidMatch) {
+            evidenceEntriesNonEid += 1;
+            continue;
+          }
+          evidenceEntriesEid += 1;
+          const eid = Number(eidMatch[1]);
+          const invalid = !Number.isFinite(eid) || eid < 1 || eid > evidenceCandidateCount;
+          if (invalid) {
+            evidenceEidInvalid += 1;
+            if (invalidSamples.length < 5) {
+              invalidSamples.push({
+                variantId: variant.id,
+                variantName,
+                bucket,
+                evidence: trimmed,
+                evidenceCandidateCount
+              });
+            }
+          }
+        }
+      }
+    }
+    const evidenceEntriesTotal = evidenceEntriesEid + evidenceEntriesNonEid;
+    const evidenceBucketsEmptyPct = bucketCount > 0 ? evidenceBucketsEmpty / bucketCount : 0;
+    const evidenceEidInvalidPct = evidenceEntriesEid > 0 ? evidenceEidInvalid / evidenceEntriesEid : 0;
+    return {
+      policy: "prompt-only",
+      variantsInPrompt: variants.length,
+      variantsInOutput: output.variants.length,
+      bucketCount,
+      evidenceBucketsEmpty,
+      evidenceBucketsEmptyPct,
+      evidenceEntriesTotal,
+      evidenceEntriesEid,
+      evidenceEntriesNonEid,
+      evidenceEidInvalid,
+      evidenceEidInvalidPct,
+      evidenceCandidatesTotal,
+      evidenceCandidatesMin,
+      evidenceCandidatesMax,
+      evidenceCandidatesAvg,
+      invalidSamples
+    };
+  }
+  /**
+   * PROMPT-ONLY task profile resolution.
+   *
+   * Firewall rule: this method is used only before the LLM call to shape prompt
+   * language. Its output must never be consumed in post-parse score/winner logic.
+   */
+  resolvePromptOnlyTaskProfile(taskPrompt, evaluationContext) {
+    try {
+      const resolution = evaluationContext?.taskTypeResolution ?? resolveTaskType(taskPrompt, {
+        fileTargets: parsePromptSpec(taskPrompt).fileConstraint.targets,
+        changedFiles: evaluationContext ? [...evaluationContext.changedFiles] : void 0
+      });
+      const taskType = resolution.taskType;
+      const limitedEmpiricalSignals = taskType !== "code";
+      return {
+        taskType,
+        confidence: resolution.confidence,
+        source: resolution.source,
+        reasoning: resolution.reasoning,
+        limitedEmpiricalSignals,
+        guidance: buildTaskProfileGuidance({
+          taskType,
+          confidence: resolution.confidence,
+          limitedEmpiricalSignals
+        })
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const taskType = "code";
+      return {
+        taskType,
+        confidence: "low",
+        source: "llm-fallback",
+        reasoning: `Prompt profile fallback used due to resolver error: ${message}`,
+        limitedEmpiricalSignals: false,
+        guidance: buildTaskProfileGuidance({
+          taskType,
+          confidence: "low",
+          limitedEmpiricalSignals: false
+        })
+      };
+    }
+  }
+  /**
+   * Map AIJudgeOutput to JudgeSynthesisResult.
+   */
+  mapToSynthesisResult(output, variants, startTime, _preScoreGateContext) {
+    const evaluations = output.variants.map((v) => {
+      const matchingVariant = variants.find(
+        (ov, idx) => ov.variant === v.id || v.id === `v${idx + 1}`
+      );
+      const variantName = matchingVariant?.variant ?? v.id;
+      const readabilityScore = v.dimensions?.readability ?? v.quality.score;
+      const maintainabilityScore = v.dimensions?.maintainability ?? v.quality.score;
+      const innovationScore = v.dimensions?.innovation ?? 50;
+      return {
+        variant: variantName,
+        declaredOverallScore: v.os,
+        qualityScore: createPercentScore(v.quality.score, "quality"),
+        strengths: [v.delivery.rationale, v.correctness.rationale, v.quality.rationale].filter(
+          (r) => r && r.trim().length > 0
+        ),
+        weaknesses: typeof v.limitation?.summary === "string" && v.limitation.summary.trim().length > 0 ? [v.limitation.summary] : [],
+        primaryReason: `delivery=${v.delivery.score} correctness=${v.correctness.score} quality=${v.quality.score}`,
+        codeQuality: {
+          correctness: createPercentScore(v.correctness.score, "correctness"),
+          readability: createPercentScore(readabilityScore, "readability"),
+          maintainability: createPercentScore(maintainabilityScore, "maintainability"),
+          performance: createPercentScore(70, "performance (not assessed)"),
+          completeness: createPercentScore(v.delivery.score, "completeness"),
+          innovation: createPercentScore(innovationScore, "innovation"),
+          ...v.dimensions?.security !== void 0 ? { security: createPercentScore(v.dimensions.security, "security") } : {}
+        },
+        bucketScores: {
+          delivery: v.delivery.score,
+          correctness: v.correctness.score,
+          quality: v.quality.score
+        }
+      };
+    });
+    const deterministicWinner = selectDeterministicWinnerFromScores(
+      evaluations.map((evaluation) => ({
+        variant: evaluation.variant,
+        eligible: true,
+        declaredOverallScore: evaluation.declaredOverallScore,
+        bucketScores: evaluation.bucketScores,
+        codeQuality: evaluation.codeQuality,
+        qualityScore: Number(evaluation.qualityScore ?? 0)
+      }))
+    );
+    const variantNames = new Set(variants.map((v) => v.variant));
+    const variantsList = variants.map((v) => ({ variant: v.variant }));
+    const rawRanking = Array.isArray(output.summary?.ranking) ? output.summary.ranking : Array.isArray(output.ranking) ? output.ranking : void 0;
+    const rankingValidation = validateRanking(rawRanking, variantNames, variantsList);
+    const legacyWinnerRaw = typeof output.winner?.variant === "string" && output.winner.variant.trim().length > 0 ? output.winner.variant.trim() : typeof output.winner?.id === "string" && output.winner.id.trim().length > 0 ? output.winner.id.trim() : "";
+    const legacyWinnerResolved = legacyWinnerRaw !== "" ? normalizeRankingIds([legacyWinnerRaw], variantsList)[0] ?? "" : "";
+    const legacyWinnerValid = legacyWinnerResolved !== "" && variantNames.has(legacyWinnerResolved);
+    const rankingLegacyDiverges = rankingValidation.valid && legacyWinnerValid && (rankingValidation.ranking[0] ?? null) !== legacyWinnerResolved;
+    const explicitNoWinner = output.winner === null;
+    if (variants.length === 1 && !explicitNoWinner) {
+      const soleVariant = variants[0]?.variant;
+      const sv01Raw = typeof output.summary?.confidence === "number" ? output.summary.confidence : 0;
+      const sv01 = Math.max(0, Math.min(1, sv01Raw));
+      const svRankingRationale = output.summary?.rankingRationale?.trim();
+      const svReasoning = svRankingRationale && svRankingRationale.length > 0 ? svRankingRationale : `Single variant evaluation: ${soleVariant}.`;
+      return {
+        winner: soleVariant ?? null,
+        evaluations,
+        reasoning: svReasoning,
+        winnerPrimaryReason: evaluations[0]?.primaryReason ?? "",
+        recommendations: [],
+        metadata: {
+          model: this.model ?? "ai-judge",
+          timestamp: /* @__PURE__ */ new Date(),
+          evaluationTimeMs: Date.now() - startTime,
+          confidence: createPercentScore(sv01 * 100, "single variant"),
+          topVariants: [soleVariant],
+          winnerSelectionMetadata: {
+            rawWinner: soleVariant,
+            finalWinner: soleVariant,
+            selectionMode: "ranking",
+            reason: "single_variant"
+          },
+          winnerSource: "ranking",
+          audit: {
+            deterministicWinner,
+            legacyWinnerResolved: legacyWinnerResolved || null,
+            legacyWinnerValid
+          }
+        }
+      };
+    }
+    let winnerId = null;
+    let winnerSource = "inconclusive";
+    let validatedRanking = null;
+    if (rankingValidation.valid && !rankingValidation.partial) {
+      validatedRanking = rankingValidation.ranking;
+    }
+    if (explicitNoWinner) {
+      winnerId = null;
+      winnerSource = "inconclusive";
+    } else if (legacyWinnerValid) {
+      winnerId = legacyWinnerResolved;
+      winnerSource = "llm-winner";
+    } else if (validatedRanking) {
+      winnerId = validatedRanking[0] ?? null;
+      winnerSource = winnerId ? "ranking" : "inconclusive";
+    }
+    const rankingDivergesFromScores = winnerId != null && winnerId !== "" && winnerId !== deterministicWinner.winner;
+    let rankingScoreInconsistency = false;
+    if (validatedRanking && validatedRanking.length > 1) {
+      const osMap = /* @__PURE__ */ new Map();
+      for (const v of output.variants) {
+        const vAny = v;
+        if (typeof vAny.os === "number" && Number.isFinite(vAny.os)) {
+          const match = variants.find((ov, idx) => ov.variant === v.id || v.id === `v${idx + 1}`);
+          const key = match?.variant ?? v.id;
+          osMap.set(key, vAny.os);
+        }
+      }
+      if (osMap.size > 0) {
+        const consistency = checkRankingScoreConsistency(validatedRanking, osMap);
+        rankingScoreInconsistency = consistency.inconsistent;
+      }
+    }
+    const winnerEvaluation = winnerId ? evaluations.find((evaluation) => evaluation.variant === winnerId) : void 0;
+    let selfConsistencyWarning;
+    if (winnerId && winnerSource !== "inconclusive") {
+      selfConsistencyWarning = computeSelfConsistencyWarning(winnerId, deterministicWinner);
+    }
+    const summaryReason = typeof output.summary?.rankingRationale === "string" && output.summary.rankingRationale.trim() ? output.summary.rankingRationale.trim() : null;
+    const fallbackReason = winnerEvaluation?.primaryReason ?? "Winner derived from validated ranking.";
+    const reasoning = summaryReason ?? fallbackReason;
+    const confidence01Raw = typeof output.summary?.confidence === "number" ? output.summary.confidence : 0;
+    const confidence01 = Math.max(0, Math.min(1, confidence01Raw));
+    const topVariants = (validatedRanking ?? deterministicWinner.scored.map((entry) => entry.variant)).slice(0, 3);
+    return {
+      winner: winnerId,
+      evaluations,
+      reasoning,
+      recommendations: [],
+      metadata: {
+        model: this.model ?? "ai-judge",
+        timestamp: /* @__PURE__ */ new Date(),
+        evaluationTimeMs: Date.now() - startTime,
+        confidence: createPercentScore(confidence01 * 100, "ai judge confidence"),
+        topVariants,
+        winnerSelectionMetadata: {
+          rawWinner: legacyWinnerRaw || null,
+          rawRanking: Array.isArray(rawRanking) ? rawRanking : null,
+          validatedRanking,
+          rankingLegacyDiverges,
+          finalWinner: winnerId,
+          selectionMode: winnerSource === "llm-winner" ? "llm-winner" : winnerSource === "ranking" ? "ranking" : "ranking-inconclusive",
+          reason: explicitNoWinner ? "explicit_no_winner" : winnerSource === "llm-winner" ? "explicit_winner" : winnerSource === "ranking" ? "ranking_first" : "llm_no_declaration",
+          margin: deterministicWinner.margin,
+          thresholds: deterministicWinner.thresholds,
+          scored: deterministicWinner.scored.map((entry) => ({
+            variant: entry.variant,
+            score: Number(entry.compositeScore),
+            source: entry.scoreSource
+          }))
+        },
+        audit: {
+          judgeType: "ai-judge",
+          deterministicWinner,
+          winnerSource,
+          rankingValidation: rankingValidation.valid ? rankingValidation.partial ? "partial_rejected" : "valid" : rankingValidation.reason,
+          rankingDivergesFromScores,
+          rankingScoreInconsistency,
+          rankingLegacyDiverges,
+          validatedRanking,
+          rawRanking: Array.isArray(rawRanking) ? rawRanking : null,
+          llmWinnerAuthority: {
+            llmDeclaredVariantRaw: legacyWinnerRaw || null,
+            llmDeclaredVariant: legacyWinnerResolved || null,
+            llmDeclaredNoWinner: explicitNoWinner,
+            llmWinnerValid: explicitNoWinner || legacyWinnerValid,
+            used: explicitNoWinner ? "explicit-no-winner" : winnerSource
+          },
+          ...selfConsistencyWarning ? { selfConsistencyWarning } : {}
+        }
+      },
+      winnerPrimaryReason: winnerEvaluation?.primaryReason ?? void 0
+    };
+  }
+  /**
+   * Factual-consistency audit (telemetry-only, NO mutation).
+   *
+   * After LLM output is parsed and validated, checks if AI rationale claims
+   * tests passed when gate data shows 'failed' or 'error'. Records warnings
+   * to synthesis.metadata.audit but does NOT mutate confidence, scores, or winner.
+   */
+  validateFactualConsistency(output, variants, preScoreGateContext, synthesis) {
+    if (!preScoreGateContext.isCodeTask || preScoreGateContext.gateResultsByVariant.size === 0) {
+      return;
+    }
+    const warnings = [];
+    const testPassClaimPattern = /\b(?:all tests? pass(?:ed|ing)?|tests? (?:are )?passing|0 fail(?:ure)?s?|no (?:test )?fail(?:ure)?s?|clean test (?:run|pass))\b/i;
+    for (const variantOutput of output.variants) {
+      const rationales = [
+        variantOutput.delivery?.rationale,
+        variantOutput.correctness?.rationale,
+        variantOutput.quality?.rationale
+      ].filter((r) => typeof r === "string" && r.length > 0).join(" ");
+      if (!testPassClaimPattern.test(rationales)) continue;
+      const resolvedVariant = variants.find(
+        (variant, index) => variant.variant === variantOutput.id || variantOutput.id === `v${index + 1}`
+      );
+      const gateVariantName = resolvedVariant?.variant ?? variantOutput.id;
+      const gateResults = preScoreGateContext.gateResultsByVariant.get(gateVariantName);
+      if (!gateResults) continue;
+      const testGate = gateResults.testGate;
+      if (testGate && (testGate.testStatus === "failed" || testGate.testStatus === "error")) {
+        warnings.push(
+          `Variant ${variantOutput.id} (${gateVariantName}): AI rationale claims tests passed but testGate.testStatus=${testGate.testStatus} (exitCode=${testGate.exitCode})`
+        );
+      }
+    }
+    const existingAudit = synthesis.metadata.audit ?? {};
+    synthesis.metadata.audit = {
+      ...existingAudit,
+      factualConsistencyPassed: warnings.length === 0,
+      factualConsistencyWarnings: warnings.length > 0 ? warnings : void 0
+    };
+  }
+  /**
+   * Persist a failed AI response to disk for post-mortem analysis.
+   * Never throws — failures here must not block the judge error path.
+   */
+  persistFailedResponse(response, taskId, label) {
+    persistJudgeFailureArtifact({ response, taskId, label });
+  }
+  repairMissingOverallScores(parsed) {
+    if (!parsed || typeof parsed !== "object") return parsed;
+    const root = parsed;
+    if (!Array.isArray(root.variants) || root.variants.length <= 1) return parsed;
+    const repairedVariants = [];
+    let changed = false;
+    for (const variant of root.variants) {
+      if (!variant || typeof variant !== "object") return parsed;
+      const entry = variant;
+      if (entry.os !== void 0) {
+        repairedVariants.push(entry);
+        continue;
+      }
+      const delivery = this.readBucketScore(entry.delivery);
+      const correctness = this.readBucketScore(entry.correctness);
+      const quality = this.readBucketScore(entry.quality);
+      if (delivery === void 0 || correctness === void 0 || quality === void 0) {
+        return parsed;
+      }
+      changed = true;
+      repairedVariants.push({
+        ...entry,
+        os: Math.round(computeFinalScore({ delivery, correctness, quality }) * 10) / 10
+      });
+    }
+    if (changed) {
+      const repairedCount = repairedVariants.filter((v, i) => {
+        const original = root.variants[i];
+        return original?.os === void 0 && v.os !== void 0;
+      }).length;
+      console.warn(
+        `[ai-judge] repairMissingOverallScores: synthesized os from bucket scores for ${repairedCount} variant(s)`
+      );
+      return { ...root, variants: repairedVariants };
+    }
+    return parsed;
+  }
+  readBucketScore(bucket) {
+    if (!bucket || typeof bucket !== "object") return void 0;
+    const score = bucket.score;
+    return typeof score === "number" && Number.isFinite(score) && score >= 0 && score <= 100 ? score : void 0;
+  }
+  classifyParseFailureReason(response) {
+    const trimmed = response.trim();
+    if (trimmed.length === 0) return "empty_output";
+    const hasJsonLikeMarkers = /[{[]/.test(trimmed);
+    return hasJsonLikeMarkers ? "malformed_json" : "no_json_payload";
+  }
+  createResponseSnippet(response) {
+    const normalized = response.replace(/\s+/g, " ").trim();
+    if (normalized.length === 0) return "<empty output>";
+    const snippet = normalized.slice(0, 300);
+    return normalized.length > 300 ? `${snippet}...` : snippet;
+  }
+  describeValidationFailure(parsed) {
+    if (!parsed || typeof parsed !== "object") {
+      return `top-level payload is ${parsed === null ? "null" : typeof parsed}`;
+    }
+    const root = parsed;
+    const keys = Object.keys(root);
+    if (!Array.isArray(root.variants)) {
+      return `missing variants array (keys=${keys.join(",") || "none"})`;
+    }
+    if (root.variants.length === 0) {
+      return "variants array is empty";
+    }
+    if (root.variants.length > 1) {
+      const missingOverallScoreIndexes = root.variants.map(
+        (variant, index) => variant && typeof variant === "object" && variant.os === void 0 ? index : -1
+      ).filter((index) => index >= 0);
+      if (missingOverallScoreIndexes.length > 0) {
+        return `multi-variant output missing os for variant indexes ${missingOverallScoreIndexes.join(",")}`;
+      }
+    }
+    return `invalid variants/summary structure (keys=${keys.join(",") || "none"})`;
+  }
+  /**
+   * Create an empty result for edge cases.
+   */
+  createEmptyResult(reason, startTime) {
+    return {
+      winner: null,
+      evaluations: [],
+      reasoning: reason,
+      recommendations: ["Provide at least one variant to evaluate"],
+      metadata: {
+        model: this.model ?? "ai-judge",
+        timestamp: /* @__PURE__ */ new Date(),
+        evaluationTimeMs: Date.now() - startTime,
+        confidence: createPercentScore(0, "no variants"),
+        topVariants: []
+      }
+    };
+  }
+};
+function createAIJudge(options) {
+  return new AIJudge(options);
+}
+
+export {
+  buildTaskProfileGuidance,
+  parseJudgeOutput,
+  AIJudge,
+  createAIJudge
+};
+//# sourceMappingURL=chunk-CKP2Q3TP.js.map