@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-TSPQONRT.js

@@ -0,0 +1,4533 @@
+import {
+  charsToTokens
+} from "./chunk-LFTQVYBB.js";
+import {
+  runLintOnDiffWithArtifacts,
+  runTestGate
+} from "./chunk-EJ42BNGY.js";
+import {
+  DETERMINISTIC_WINNER_WEIGHTS,
+  THREE_BUCKET_RUBRIC_FORMULA_TEXT,
+  THREE_BUCKET_RUBRIC_PERCENT_TEXT
+} from "./chunk-73NCTWKL.js";
+import {
+  formatVerificationEvidenceQualitySummary
+} from "./chunk-E74LUIID.js";
+import {
+  formatVerificationProvenanceForPrompt,
+  resolveJudgeEvaluationContext
+} from "./chunk-66AGFTBQ.js";
+import {
+  extractTaskContract
+} from "./chunk-AZQILSNQ.js";
+import {
+  categorizeFile,
+  extractChangedFilesMeta
+} from "./chunk-CFBIG37O.js";
+import {
+  hasRecordedTestExecutionEvidence,
+  hasTestExecutionProvenance,
+  hasUnrecognizedRecordedTestStatus,
+  normalizeRecordedTestStatus
+} from "./chunk-KT6VHSPF.js";
+import {
+  taskTypeSignalsEnabled
+} from "./chunk-W4OMESPG.js";
+import {
+  parsePromptSpec
+} from "./chunk-X6UIEADS.js";
+import {
+  parseDiffGitHeaderPaths
+} from "./chunk-C3L6YQ7P.js";
+import {
+  runBuildGate
+} from "./chunk-STJOHHSF.js";
+import {
+  resolveVerificationChannelScope
+} from "./chunk-MCPQNJMK.js";
+import {
+  resolveJudgeConfig
+} from "./chunk-IZZK3H6I.js";
+import {
+  parseVariantIdentifier
+} from "./chunk-YWNAHW24.js";
+import {
+  escapeEvidenceForJudgePromptDisplay,
+  escapePathForJudgePromptDisplay,
+  extractCleanStdout,
+  extractDiffText,
+  frameUntrustedJudgeEvidence,
+  frameUntrustedJudgeTaskText,
+  presentUntrustedJudgeEvidence,
+  redactSuspiciousJudgePromptPatterns
+} from "./chunk-IATQ7NBI.js";
+import {
+  JUDGE_FEATURE_FLAGS
+} from "./chunk-BSE4R6XD.js";
+import {
+  isProjectConfigPath,
+  isProjectTestPath,
+  languageForProjectPath
+} from "./chunk-UDMS5AD3.js";
+import {
+  describeVerificationCommand
+} from "./chunk-4BIPZBT7.js";
+import {
+  ProviderRegistry
+} from "./chunk-AT4TNPWW.js";
+import {
+  sanitizeString
+} from "./chunk-LPITVM7M.js";
+import {
+  POETIC_LAB_ID,
+  POETIC_LAB_MODE,
+  POETIC_LAB_RUN_ID,
+  readEnv
+} from "./chunk-5DLKYTQX.js";
+
+// src/core/judge/pre-score-gates.ts
+import path from "path";
+
+// src/core/judge/requirement-validator.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+async function validateRequirements(requirements, variantPath, changedFiles) {
+  if (requirements.length === 0) {
+    return {
+      satisfied: true,
+      satisfiedCount: 0,
+      totalCount: 0,
+      missingRequirements: [],
+      details: []
+    };
+  }
+  const details = [];
+  let satisfiedCount = 0;
+  for (const requirement of requirements) {
+    let result;
+    switch (requirement.type) {
+      case "cli-flag":
+        result = {
+          ...await validateCliFlag(
+            requirement.metadata?.flagName ?? "",
+            variantPath,
+            changedFiles
+          ),
+          verificationMethod: "cli_flag_scan",
+          verificationDepth: "structural"
+        };
+        break;
+      case "file-constraint":
+        result = {
+          ...validateFileConstraint(
+            requirement.metadata?.files ?? [],
+            requirement.metadata?.mode ?? "soft",
+            changedFiles
+          ),
+          verificationMethod: "file_target_match",
+          verificationDepth: "structural"
+        };
+        break;
+      case "tests":
+        result = {
+          ...validateTestsRequirement(changedFiles),
+          verificationMethod: "test_file_presence",
+          verificationDepth: "lexical"
+        };
+        break;
+      case "feature":
+      case "explicit":
+        result = {
+          ...await validateFeatureRequirement(requirement.description, variantPath, changedFiles),
+          verificationMethod: "keyword_match",
+          verificationDepth: "lexical"
+        };
+        break;
+      default:
+        result = {
+          satisfied: false,
+          reason: "Unknown requirement type",
+          verificationMethod: "unknown",
+          verificationDepth: "lexical"
+        };
+    }
+    if (result.satisfied) {
+      satisfiedCount++;
+    }
+    details.push({
+      requirement,
+      satisfied: result.satisfied,
+      reason: result.reason,
+      verificationMethod: result.verificationMethod,
+      verificationDepth: result.verificationDepth
+    });
+  }
+  const missingRequirements = details.filter((d) => !d.satisfied).map((d) => d.requirement.description);
+  return {
+    satisfied: satisfiedCount === requirements.length,
+    satisfiedCount,
+    totalCount: requirements.length,
+    missingRequirements,
+    details
+  };
+}
+function validateTestsRequirement(changedFiles) {
+  const testFiles = changedFiles.filter((f) => isProjectTestPath(f));
+  if (testFiles.length === 0) {
+    return { satisfied: false, reason: "No test files were added or modified" };
+  }
+  return {
+    satisfied: true,
+    reason: `Modified ${testFiles.length} test file(s): ${testFiles.slice(0, 3).join(", ")}`
+  };
+}
+async function validateCliFlag(flagName, variantPath, changedFiles) {
+  if (!flagName) {
+    return { satisfied: false, reason: "No flag name provided" };
+  }
+  const cliFiles = changedFiles.filter(
+    (f) => f.includes("src/cli/") || f.toLowerCase().includes("option") || f.toLowerCase().includes("handler") || f.toLowerCase().includes("config")
+  );
+  if (cliFiles.length === 0) {
+    return {
+      satisfied: false,
+      reason: `No CLI-related files modified for flag --${flagName}`
+    };
+  }
+  let definitionFound = false;
+  let definitionReason = "";
+  const definitionFailedReads = [];
+  for (const file of cliFiles) {
+    try {
+      const filePath = join(variantPath, file);
+      const content = await readFile(filePath, "utf-8");
+      const camelFlagName = flagName.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+      const flagPatterns = [
+        new RegExp(`['"\`]--${flagName}['"\`]`, "i"),
+        // '--flag-name'
+        new RegExp(`['"\`]${flagName}['"\`].*:`, "i"),
+        // 'flag-name':
+        new RegExp(`['"]${flagName}['"]\\s*:`, "i"),
+        // 'flag-name':
+        new RegExp(`${camelFlagName}\\s*:`, "i"),
+        // camelCase: flagName:
+        new RegExp(`option\\(['"\`]${flagName}['"\`]`, "i")
+        // option('flag-name')
+      ];
+      if (flagPatterns.some((pattern) => pattern.test(content))) {
+        definitionFound = true;
+        definitionReason = `Flag defined in ${file}`;
+        break;
+      }
+    } catch (_error) {
+      definitionFailedReads.push(file);
+    }
+  }
+  if (definitionFailedReads.length > 0) {
+    console.warn(
+      `[requirement-validator] ${definitionFailedReads.length}/${cliFiles.length} files unreadable during CLI flag definition check (${definitionFailedReads.slice(0, 3).join(", ")})`
+    );
+  }
+  if (!definitionFound) {
+    return {
+      satisfied: false,
+      reason: `Flag --${flagName} definition not found in CLI files`
+    };
+  }
+  let propagationFound = false;
+  let propagationReason = "";
+  const propagationFailedReads = [];
+  for (const file of cliFiles) {
+    try {
+      const filePath = join(variantPath, file);
+      const content = await readFile(filePath, "utf-8");
+      const camelFlagName = flagName.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+      const usagePatterns = [
+        new RegExp(`options\\.${camelFlagName}`, "i"),
+        // options.maxRetries
+        new RegExp(`opts\\.${camelFlagName}`, "i"),
+        // opts.maxRetries
+        new RegExp(`\\[['"\`]${flagName}['"\`]\\]`, "i"),
+        // ['max-retries']
+        new RegExp(`get\\(['"\`]${flagName}['"\`]\\)`, "i"),
+        // get('max-retries')
+        new RegExp(`const\\s+${camelFlagName}\\s*=`, "i"),
+        // const maxRetries =
+        new RegExp(`\\b${camelFlagName}\\s*:`, "i")
+        // maxRetries: in object
+      ];
+      if (usagePatterns.some((pattern) => pattern.test(content))) {
+        propagationFound = true;
+        propagationReason = `Flag propagated in ${file}`;
+        break;
+      }
+    } catch (_error) {
+      propagationFailedReads.push(file);
+    }
+  }
+  if (propagationFailedReads.length > 0) {
+    console.warn(
+      `[requirement-validator] ${propagationFailedReads.length}/${cliFiles.length} files unreadable during CLI flag propagation check (${propagationFailedReads.slice(0, 3).join(", ")})`
+    );
+  }
+  if (!propagationFound) {
+    return {
+      satisfied: false,
+      reason: `Flag --${flagName} defined but not propagated to handler`
+    };
+  }
+  return {
+    satisfied: true,
+    reason: `Flag --${flagName} implemented: ${definitionReason}, ${propagationReason}`
+  };
+}
+function validateFileConstraint(requiredFiles, mode, changedFiles) {
+  if (requiredFiles.length === 0) {
+    return { satisfied: true, reason: "No file constraints specified" };
+  }
+  const normalizedChangedFiles = changedFiles.map(
+    (f) => f.toLowerCase().replace(/^\.\//, "").replace(/\\/g, "/")
+  );
+  const normalizedTargets = requiredFiles.map(
+    (f) => f.toLowerCase().replace(/^\.\//, "").replace(/\\/g, "/")
+  );
+  if (mode === "hard") {
+    if (normalizedChangedFiles.length === 0) {
+      return { satisfied: false, reason: "No files changed under FILES_ONLY constraint" };
+    }
+    const extraFiles = normalizedChangedFiles.filter((f) => {
+      return !normalizedTargets.some((target) => {
+        if (f === target) return true;
+        if (target.endsWith("/") && f.startsWith(target)) return true;
+        if (!target.endsWith("/") && f.startsWith(`${target}/`)) return true;
+        if (target.includes("*")) {
+          const escaped = target.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+          const regexStr = escaped.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
+          return new RegExp(`^${regexStr}$`).test(f);
+        }
+        return false;
+      });
+    });
+    if (extraFiles.length > 0) {
+      return {
+        satisfied: false,
+        reason: `Modified files outside FILES_ONLY targets: ${extraFiles.slice(0, 5).join(", ")}${extraFiles.length > 5 ? "..." : ""}`
+      };
+    }
+    return {
+      satisfied: true,
+      reason: `All changes contained within FILES_ONLY targets (${requiredFiles.length} targets)`
+    };
+  }
+  const modifiedTargets = requiredFiles.filter((requiredFile) => {
+    const normalized = requiredFile.toLowerCase().replace(/^\.\//, "").replace(/\\/g, "/");
+    if (normalizedChangedFiles.includes(normalized)) return true;
+    if (normalized.endsWith("/")) {
+      return normalizedChangedFiles.some((f) => f.startsWith(normalized));
+    }
+    if (normalized.includes("*")) {
+      const escaped = normalized.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+      const regexStr = escaped.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
+      const regex = new RegExp(`^${regexStr}$`);
+      return normalizedChangedFiles.some((f) => regex.test(f));
+    }
+    return normalizedChangedFiles.some((f) => f.startsWith(`${normalized}/`));
+  });
+  if (modifiedTargets.length > 0) {
+    return {
+      satisfied: true,
+      reason: `Modified FILE target(s): ${modifiedTargets.join(", ")}`
+    };
+  }
+  return {
+    satisfied: false,
+    reason: `No FILE targets modified: ${requiredFiles.join(", ")}`
+  };
+}
+async function validateFeatureRequirement(description, variantPath, changedFiles) {
+  if (changedFiles.length === 0) {
+    return {
+      satisfied: false,
+      reason: "No files changed to implement feature"
+    };
+  }
+  const descriptionLower = (description ?? "").toLowerCase();
+  if (/\btests?\b/.test(descriptionLower)) {
+    const hasTestLikeChange = changedFiles.some((file) => isProjectTestPath(file));
+    if (hasTestLikeChange) {
+      return {
+        satisfied: true,
+        reason: "Test requirement satisfied by test-like file changes."
+      };
+    }
+  }
+  const keywords = extractKeywords(description);
+  if (keywords.length === 0) {
+    return {
+      satisfied: true,
+      reason: `Files changed: ${changedFiles.slice(0, 3).join(", ")}${changedFiles.length > 3 ? "..." : ""}`
+    };
+  }
+  const matchedKeywords = /* @__PURE__ */ new Set();
+  let readableFiles = 0;
+  let filenameMatchCount = 0;
+  const matchedFiles = [];
+  const filenameMatchedFiles = [];
+  const featureFailedReads = [];
+  for (const file of changedFiles.slice(0, 50)) {
+    const fileLower = file.toLowerCase();
+    const filePathMatches = keywords.some((keyword) => fileLower.includes(keyword.toLowerCase()));
+    if (filePathMatches) {
+      filenameMatchCount++;
+      filenameMatchedFiles.push(file);
+    }
+    try {
+      const filePath = join(variantPath, file);
+      const content = await readFile(filePath, "utf-8");
+      readableFiles++;
+      const contentLower = content.toLowerCase();
+      let fileMatchCount = 0;
+      for (const keyword of keywords) {
+        const normalizedKeyword = keyword.toLowerCase();
+        if (contentLower.includes(normalizedKeyword)) {
+          fileMatchCount++;
+          matchedKeywords.add(normalizedKeyword);
+        }
+      }
+      if (fileMatchCount > 0) {
+        matchedFiles.push(file);
+      }
+    } catch (_error) {
+      featureFailedReads.push(file);
+    }
+  }
+  if (featureFailedReads.length > 0) {
+    const totalFiles = Math.min(changedFiles.length, 10);
+    console.warn(
+      `[requirement-validator] ${featureFailedReads.length}/${totalFiles} files unreadable during feature keyword matching (${featureFailedReads.slice(0, 3).join(", ")})`
+    );
+  }
+  const satisfactionThreshold = Math.min(6, Math.max(1, Math.ceil(keywords.length * 0.3)));
+  const matchCount = matchedKeywords.size;
+  const satisfied = matchCount >= satisfactionThreshold;
+  if (satisfied) {
+    return {
+      satisfied: true,
+      reason: `Feature keywords found in ${matchedFiles.length} files (${matchCount}/${keywords.length} unique keywords)`
+    };
+  }
+  if (readableFiles === 0 && filenameMatchCount > 0) {
+    return {
+      satisfied: true,
+      reason: `Requirement keywords not found in file contents (unreadable), but matched ${filenameMatchCount} filenames: ${filenameMatchedFiles.slice(0, 3).join(", ")}${filenameMatchedFiles.length > 3 ? "..." : ""}`
+    };
+  }
+  return {
+    satisfied: false,
+    reason: `Insufficient keyword matches: ${matchCount}/${keywords.length} unique keywords (threshold: ${satisfactionThreshold}, readableFiles: ${readableFiles}, filenameMatches: ${filenameMatchCount})`
+  };
+}
+function extractKeywords(description) {
+  const stopWords = /* @__PURE__ */ new Set([
+    "a",
+    "an",
+    "and",
+    "the",
+    "to",
+    "for",
+    "of",
+    "in",
+    "on",
+    "at",
+    "by",
+    "with",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "should",
+    "could",
+    "may",
+    "might",
+    "must",
+    "can",
+    "this",
+    "that",
+    "these",
+    "those",
+    // Generic instruction words (not useful for verification)
+    "something",
+    "anything",
+    "everything",
+    "feature",
+    "features",
+    "task",
+    "change",
+    "changes",
+    "update",
+    "updates",
+    "fix",
+    "fixes",
+    "implement",
+    "implements",
+    "implementation",
+    "add",
+    "adds",
+    "remove",
+    "removes",
+    "create",
+    "creates",
+    "support",
+    "supports",
+    "ensure",
+    "ensures",
+    "verify",
+    "verifies",
+    "validate",
+    "validates",
+    "tests",
+    "test"
+  ]);
+  const tokens = /* @__PURE__ */ new Set();
+  const raw = description ?? "";
+  const candidates = raw.match(/[A-Za-z][A-Za-z0-9_-]*/g) ?? [];
+  const splitCamelCase = (value) => {
+    const parts = value.split(/(?<=[a-z0-9])(?=[A-Z])/g);
+    return parts.length > 1 ? parts : [value];
+  };
+  for (const candidate of candidates) {
+    const normalized = candidate.replace(/[^A-Za-z0-9_-]/g, "");
+    if (!normalized) continue;
+    const pieces = normalized.split(/[-_]/g).flatMap((p) => splitCamelCase(p));
+    for (const piece of pieces) {
+      const lower = piece.toLowerCase();
+      if (lower.length <= 2) continue;
+      if (stopWords.has(lower)) continue;
+      tokens.add(lower);
+    }
+  }
+  return Array.from(tokens);
+}
+
+// src/core/judge/pre-score-gates.ts
+function channelCommands(channel) {
+  if (Array.isArray(channel.commands) && channel.commands.length > 0) return channel.commands;
+  if (typeof channel.command === "string" && channel.command.trim()) return [channel.command];
+  return [];
+}
+var BUILD_CHANNEL_DEFAULT_TIMEOUT_MS = 6e4;
+function classifyBuildGateDominance(result) {
+  if (result.exitCode === 124) return "timeout";
+  if (result.verificationCoverage?.status === "skipped_no_command" || result.verificationCoverage?.status === "skipped_tool_unavailable") {
+    return "unavailable";
+  }
+  if (result.signal === "fail") return "fail";
+  if (result.signal === "pass") return "pass";
+  return "unavailable";
+}
+function aggregateBuildGateResults(results) {
+  if (results.length === 0) {
+    return {
+      signal: "unknown",
+      errors: [],
+      baselineComparisonAvailable: false,
+      baselineHealthy: false,
+      fatalErrorCount: 0,
+      typeErrorCount: 0,
+      warningCount: 0,
+      verificationCoverage: {
+        status: "skipped_no_command",
+        reason: "No build commands ran."
+      }
+    };
+  }
+  if (results.length === 1) return results[0];
+  const representative = results.find((r) => classifyBuildGateDominance(r) === "fail") ?? results.find((r) => classifyBuildGateDominance(r) === "timeout") ?? results.find((r) => classifyBuildGateDominance(r) === "unavailable") ?? results[0];
+  const signal = representative.signal;
+  const strongerThanUnavailable = results.some((r) => {
+    const tier = classifyBuildGateDominance(r);
+    return tier === "fail" || tier === "timeout";
+  });
+  const unavailableCoverage = results.find(
+    (r) => r.verificationCoverage?.status === "skipped_no_command" || r.verificationCoverage?.status === "skipped_tool_unavailable"
+  )?.verificationCoverage;
+  const errors = results.flatMap((r) => r.errors);
+  const newErrors = results.some((r) => r.newErrors) ? results.flatMap((r) => r.newErrors ?? []) : void 0;
+  return {
+    signal,
+    errors,
+    ...newErrors ? {
+      newErrors,
+      newErrorCount: newErrors.length
+    } : {},
+    baselineComparisonAvailable: results.some((r) => r.baselineComparisonAvailable),
+    baselineHealthy: representative.baselineHealthy,
+    fatalErrorCount: results.reduce((sum, r) => sum + r.fatalErrorCount, 0),
+    typeErrorCount: results.reduce((sum, r) => sum + r.typeErrorCount, 0),
+    warningCount: results.reduce((sum, r) => sum + r.warningCount, 0),
+    // Counts are only fully available when every command produced structured counts.
+    compilerCountsAvailable: results.every((r) => r.compilerCountsAvailable !== false) ? results.some((r) => r.compilerCountsAvailable === true) ? true : void 0 : false,
+    exitCode: representative.exitCode,
+    durationMs: results.reduce((sum, r) => sum + (r.durationMs ?? 0), 0),
+    command: representative.command,
+    stdoutTail: representative.stdoutTail,
+    stderrTail: representative.stderrTail,
+    outputTail: representative.outputTail,
+    verificationCoverage: signal === "pass" ? { status: "verified", command: representative.command } : !strongerThanUnavailable && unavailableCoverage ? unavailableCoverage : signal === "unknown" ? representative.verificationCoverage ?? {
+      status: "unverified",
+      command: representative.command,
+      reason: "One or more scoped build commands could not certify the gate."
+    } : representative.verificationCoverage ?? {
+      status: "unverified",
+      command: representative.command
+    }
+  };
+}
+function aggregateLintGateResults(artifacts) {
+  if (artifacts.length === 0) {
+    return {
+      passed: false,
+      errorCount: 0,
+      warningCount: 0,
+      filesWithIssues: [],
+      exitCode: 1,
+      command: "",
+      durationMs: 0,
+      verificationCoverage: {
+        status: "skipped_no_command",
+        reason: "No lint commands ran."
+      }
+    };
+  }
+  const files = /* @__PURE__ */ new Set();
+  let errorCount = 0;
+  let warningCount = 0;
+  let durationMs = 0;
+  for (const artifact of artifacts) {
+    errorCount += artifact.result?.errorCount ?? 0;
+    warningCount += artifact.result?.warningCount ?? 0;
+    durationMs += artifact.durationMs ?? 0;
+    for (const file of artifact.result?.filesWithIssues ?? []) {
+      files.add(file);
+    }
+  }
+  const anyTimeout = artifacts.some((a) => a.exitCode === 124);
+  const anyFailed = artifacts.some(
+    (a) => a.exitCode !== 0 && a.exitCode !== 124 && a.verificationCoverage?.status !== "skipped_no_command" && a.verificationCoverage?.status !== "skipped_tool_unavailable"
+  );
+  const anyUnavailable = artifacts.some(
+    (a) => a.verificationCoverage?.status === "skipped_no_command" || a.verificationCoverage?.status === "skipped_tool_unavailable"
+  );
+  const representative = artifacts.find(
+    (a) => a.exitCode !== 0 && a.exitCode !== 124 && a.verificationCoverage?.status !== "skipped_no_command" && a.verificationCoverage?.status !== "skipped_tool_unavailable"
+  ) ?? artifacts.find((a) => a.exitCode === 124) ?? artifacts.find(
+    (a) => a.verificationCoverage?.status === "skipped_no_command" || a.verificationCoverage?.status === "skipped_tool_unavailable"
+  ) ?? artifacts[0];
+  const passed = !anyFailed && !anyTimeout && !anyUnavailable && artifacts.every(lintArtifactPassed);
+  return {
+    passed,
+    errorCount,
+    warningCount,
+    filesWithIssues: Array.from(files),
+    // Dominant representative supplies exit/status — do not force 124 when a
+    // real non-timeout failure outranks a concurrent timeout (A8).
+    exitCode: representative.exitCode,
+    command: representative.command,
+    durationMs,
+    verificationCoverage: anyFailed || anyTimeout ? representative.verificationCoverage ?? {
+      status: "unverified",
+      command: representative.command
+    } : anyUnavailable ? {
+      status: "skipped_tool_unavailable",
+      command: representative.command,
+      reason: "One or more scoped lint commands were unavailable."
+    } : { status: "verified", command: representative.command }
+  };
+}
+async function runMultiCommandBuildGate(variantPath, changedFiles, baselineHealthy, commands, options) {
+  let remaining = options?.timeoutMs ?? BUILD_CHANNEL_DEFAULT_TIMEOUT_MS;
+  const results = [];
+  for (const command of commands) {
+    if (remaining <= 0) {
+      results.push({
+        signal: "fail",
+        errors: [],
+        baselineComparisonAvailable: options?.baselineErrorKeys !== void 0,
+        baselineHealthy,
+        fatalErrorCount: 0,
+        typeErrorCount: 0,
+        warningCount: 0,
+        compilerCountsAvailable: false,
+        exitCode: 124,
+        durationMs: 0,
+        command,
+        outputTail: "Build command skipped: channel timeout budget exhausted.",
+        verificationCoverage: {
+          status: "unverified",
+          command,
+          reason: "Channel timeout budget exhausted before this build command ran."
+        }
+      });
+      continue;
+    }
+    const result = await runBuildGate(variantPath, changedFiles, baselineHealthy, {
+      baselineErrorKeys: options?.baselineErrorKeys,
+      typecheckExecutable: options?.typecheckExecutable,
+      abortSignal: options?.abortSignal,
+      command,
+      timeoutMs: remaining
+    });
+    remaining = Math.max(0, remaining - (result.durationMs ?? 0));
+    results.push(result);
+  }
+  return aggregateBuildGateResults(results);
+}
+async function runMultiCommandLintGate(variantPath, commands, options) {
+  let remaining = options?.timeoutMs ?? resolveLintGateTimeoutMs();
+  const artifacts = [];
+  for (const command of commands) {
+    if (remaining <= 0) {
+      artifacts.push({
+        command,
+        exitCode: 124,
+        durationMs: 0,
+        outputTail: "Lint command skipped: channel timeout budget exhausted.",
+        result: null,
+        verificationCoverage: {
+          status: "unverified",
+          command,
+          reason: "Channel timeout budget exhausted before this lint command ran."
+        }
+      });
+      continue;
+    }
+    const artifact = await runLintOnDiffWithArtifacts(variantPath, {
+      timeoutMs: remaining,
+      abortSignal: options?.abortSignal,
+      command
+    });
+    remaining = Math.max(0, remaining - (artifact.durationMs ?? 0));
+    artifacts.push(artifact);
+  }
+  return aggregateLintGateResults(artifacts);
+}
+var NON_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".md",
+  ".txt",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".csv",
+  ".xml",
+  ".svg",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".ico",
+  ".webp",
+  ".lock"
+]);
+var NON_SOURCE_BASENAMES = /* @__PURE__ */ new Set([
+  ".gitignore",
+  ".editorconfig",
+  ".prettierrc",
+  ".eslintignore",
+  ".npmignore",
+  ".dockerignore",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "bun.lockb",
+  "bun.lock",
+  "cargo.lock",
+  "gemfile.lock",
+  "composer.lock"
+]);
+function isNonSourceFile(filePath) {
+  const normalized = path.basename(filePath).toLowerCase();
+  if (isProjectConfigPath(filePath)) {
+    return false;
+  }
+  if (NON_SOURCE_BASENAMES.has(normalized)) {
+    return true;
+  }
+  const ext = path.extname(normalized);
+  return NON_SOURCE_EXTENSIONS.has(ext);
+}
+function isNonSourceOnly(changedFiles) {
+  if (changedFiles.length === 0) return false;
+  return changedFiles.every((filePath) => isNonSourceFile(filePath));
+}
+var LINT_GATE_DEFAULT_TIMEOUT_MS = 3e4;
+function resolveLintGateTimeoutMs() {
+  const raw = Number(process.env.POETIC_LINT_GATE_TIMEOUT_MS);
+  if (!Number.isFinite(raw) || raw <= 0) return LINT_GATE_DEFAULT_TIMEOUT_MS;
+  return Math.min(Math.max(raw, 5e3), 12e4);
+}
+function buildTestVerificationCoverage(testGate) {
+  if (testGate.availability === "unavailable") {
+    return {
+      status: "skipped_no_command",
+      command: testGate.command,
+      reason: testGate.outputTail ?? "Verification unavailable: no task-relevant covering command for the changed files."
+    };
+  }
+  if (testGate.testStatus === "not_run") {
+    return {
+      status: "skipped_no_command",
+      command: testGate.command,
+      reason: "Test gate did not run tests."
+    };
+  }
+  if (testGate.testStatus === "timeout" || testGate.testStatus === "error") {
+    return {
+      status: "unverified",
+      command: testGate.command,
+      reason: `Test gate ended with status ${testGate.testStatus}.`
+    };
+  }
+  return {
+    status: "verified",
+    command: testGate.command
+  };
+}
+var SCOPED_CHANNEL_UNAVAILABLE_REASON = "Verification unavailable: no task-relevant covering command for the changed files.";
+var SCOPED_CHANNEL_OUT_OF_SCOPE_REASON = "Build channel is out of scope for the changed files.";
+function outOfScopeScopedBuildGate(baselineHealthy) {
+  return {
+    signal: "unknown",
+    errors: [],
+    baselineComparisonAvailable: false,
+    baselineHealthy,
+    fatalErrorCount: 0,
+    typeErrorCount: 0,
+    warningCount: 0,
+    verificationCoverage: {
+      status: "skipped_not_relevant",
+      reason: SCOPED_CHANNEL_OUT_OF_SCOPE_REASON
+    }
+  };
+}
+function unavailableScopedBuildGate(baselineHealthy) {
+  return {
+    signal: "unknown",
+    errors: [],
+    baselineComparisonAvailable: false,
+    baselineHealthy,
+    fatalErrorCount: 0,
+    typeErrorCount: 0,
+    warningCount: 0,
+    verificationCoverage: {
+      status: "skipped_no_command",
+      reason: SCOPED_CHANNEL_UNAVAILABLE_REASON
+    }
+  };
+}
+function scopedNonRelevantBuildGate(baselineHealthy, availability) {
+  if (availability === "out_of_scope") {
+    return outOfScopeScopedBuildGate(baselineHealthy);
+  }
+  return unavailableScopedBuildGate(baselineHealthy);
+}
+function unavailableScopedLintGate() {
+  return {
+    passed: false,
+    errorCount: 0,
+    warningCount: 0,
+    filesWithIssues: [],
+    exitCode: 0,
+    command: "",
+    durationMs: 0,
+    verificationCoverage: {
+      status: "skipped_no_command",
+      reason: SCOPED_CHANNEL_UNAVAILABLE_REASON
+    }
+  };
+}
+function unavailableScopedTestGate() {
+  return {
+    testStatus: "not_run",
+    availability: "unavailable",
+    skipReason: "no-supported-test-runner",
+    testsRun: 0,
+    testsPassed: 0,
+    testsFailed: 0,
+    duration: 0,
+    filesTested: [],
+    command: "",
+    scope: "none",
+    outputTail: SCOPED_CHANNEL_UNAVAILABLE_REASON
+  };
+}
+var CODE_INTENTS = ["implementation", "bugfix", "refactor"];
+function isCodeIntent(kind) {
+  return CODE_INTENTS.includes(kind);
+}
+function isUnavailableVerificationCoverage(coverage) {
+  return coverage?.status === "skipped_no_command" || coverage?.status === "skipped_tool_unavailable" || coverage?.status === "unverified";
+}
+function lintArtifactPassed(lintArtifact) {
+  if (isUnavailableVerificationCoverage(lintArtifact.verificationCoverage)) {
+    return false;
+  }
+  return lintArtifact.exitCode === 0 && lintArtifact.result?.success === true;
+}
+async function runPreScoreGates(variantPath, changedFiles, requirements, baselineHealthy, options) {
+  const runBuildGateEnabled = options?.runBuildGate !== false;
+  const runLintGateEnabled = options?.runLintGate === true;
+  const variant = options?.variant;
+  const shouldRunTestGate = options?.runTestGate ?? false;
+  const explicitTestRequirement = hasExplicitTestExecutionRequirement(requirements);
+  const verificationChannelScope = resolveVerificationChannelScope(variantPath, changedFiles);
+  const channelScopeActive = verificationChannelScope.scoped;
+  const buildChannelRelevant = !channelScopeActive || verificationChannelScope.build.relevant === true;
+  const lintChannelRelevant = !channelScopeActive || verificationChannelScope.lint.relevant === true;
+  const testChannelRelevant = !channelScopeActive || verificationChannelScope.test.relevant === true;
+  const scopedBuildCommands = channelScopeActive ? channelCommands(verificationChannelScope.build) : [];
+  const scopedLintCommands = channelScopeActive ? channelCommands(verificationChannelScope.lint) : [];
+  const scopedBuildCommand = scopedBuildCommands[0];
+  const scopedLintCommand = scopedLintCommands[0];
+  if (isNonSourceOnly(changedFiles)) {
+    const requirementGate2 = await validateRequirements(requirements, variantPath, changedFiles);
+    let testGate2;
+    if (variant && shouldRunTestGate && explicitTestRequirement) {
+      testGate2 = await runTestGate(variant, variantPath, {
+        enabled: true,
+        mode: options?.testGateMode ?? "touched",
+        abortSignal: options?.abortSignal
+      });
+    }
+    const buildGate2 = {
+      signal: "unknown",
+      errors: [],
+      baselineComparisonAvailable: false,
+      baselineHealthy,
+      fatalErrorCount: 0,
+      typeErrorCount: 0,
+      warningCount: 0,
+      verificationCoverage: {
+        status: "skipped_not_relevant",
+        reason: "Only non-source files changed."
+      }
+    };
+    const isEligible2 = true;
+    const diagnosticReason2 = explicitTestRequirement && (!testGate2 || testGate2.testStatus === "not_run") ? "telemetry: explicit test requirement not met: no tests run" : void 0;
+    const buildPassed2 = buildGate2.signal === "pass";
+    return {
+      requirementGate: requirementGate2,
+      buildGate: buildGate2,
+      lintGate: void 0,
+      testGate: testGate2,
+      buildPassed: buildPassed2,
+      lintPassed: false,
+      isEligible: isEligible2,
+      diagnosticReason: diagnosticReason2,
+      verificationCoverage: {
+        build: buildGate2.verificationCoverage ?? {
+          status: "skipped_not_relevant",
+          reason: "Only non-source files changed."
+        },
+        lint: {
+          status: "skipped_not_relevant",
+          reason: "Only non-source files changed."
+        },
+        ...testGate2 ? {
+          test: buildTestVerificationCoverage(testGate2)
+        } : {}
+      }
+    };
+  }
+  if (!runBuildGateEnabled) {
+    const requirementGate2 = await validateRequirements(requirements, variantPath, changedFiles);
+    const buildGate2 = {
+      signal: "unknown",
+      errors: [],
+      baselineComparisonAvailable: false,
+      baselineHealthy,
+      fatalErrorCount: 0,
+      typeErrorCount: 0,
+      warningCount: 0,
+      verificationCoverage: {
+        status: "skipped_not_relevant",
+        reason: "Build gate was disabled for this run."
+      }
+    };
+    let lintGate2;
+    if (runLintGateEnabled) {
+      if (!lintChannelRelevant) {
+        lintGate2 = unavailableScopedLintGate();
+      } else if (scopedLintCommands.length > 0) {
+        lintGate2 = await runMultiCommandLintGate(variantPath, scopedLintCommands, {
+          abortSignal: options?.abortSignal,
+          timeoutMs: resolveLintGateTimeoutMs()
+        });
+      } else {
+        const lintArtifact = await runLintOnDiffWithArtifacts(variantPath, {
+          timeoutMs: resolveLintGateTimeoutMs(),
+          abortSignal: options?.abortSignal,
+          command: scopedLintCommand
+        });
+        lintGate2 = {
+          passed: lintArtifactPassed(lintArtifact),
+          errorCount: lintArtifact.result?.errorCount ?? 0,
+          warningCount: lintArtifact.result?.warningCount ?? 0,
+          filesWithIssues: lintArtifact.result?.filesWithIssues ?? [],
+          exitCode: lintArtifact.exitCode,
+          command: lintArtifact.command,
+          durationMs: lintArtifact.durationMs,
+          verificationCoverage: lintArtifact.verificationCoverage
+        };
+      }
+    }
+    let testGate2;
+    if (variant && shouldRunTestGate) {
+      if (!testChannelRelevant) {
+        testGate2 = unavailableScopedTestGate();
+      } else {
+        testGate2 = await runTestGate(variant, variantPath, {
+          enabled: true,
+          mode: options?.testGateMode ?? "touched",
+          abortSignal: options?.abortSignal
+        });
+      }
+    }
+    const buildPassed2 = buildGate2.signal === "pass";
+    const lintPassed2 = lintGate2?.passed ?? false;
+    if (lintGate2 && lintGate2.exitCode > 1) {
+      console.warn(
+        `[pre-score-gates] Lint tool error (exit ${lintGate2.exitCode}) - treating as unknown`
+      );
+    }
+    const isEligible2 = true;
+    const diagnosticReason2 = explicitTestRequirement && (!testGate2 || testGate2.testStatus === "not_run") ? "telemetry: explicit test requirement not met: no tests run" : void 0;
+    return {
+      requirementGate: requirementGate2,
+      buildGate: buildGate2,
+      lintGate: lintGate2,
+      testGate: testGate2,
+      buildPassed: buildPassed2,
+      lintPassed: lintPassed2,
+      isEligible: isEligible2,
+      diagnosticReason: diagnosticReason2,
+      verificationCoverage: {
+        build: buildGate2.verificationCoverage ?? {
+          status: "skipped_not_relevant",
+          reason: "Build gate was disabled for this run."
+        },
+        lint: lintGate2?.verificationCoverage ?? {
+          status: "skipped_not_relevant",
+          reason: "Lint gate was disabled for this run."
+        },
+        ...testGate2 ? {
+          test: buildTestVerificationCoverage(testGate2)
+        } : {}
+      }
+    };
+  }
+  const requirementPromise = validateRequirements(requirements, variantPath, changedFiles);
+  const buildPromise = !buildChannelRelevant ? Promise.resolve(
+    scopedNonRelevantBuildGate(baselineHealthy, verificationChannelScope.build.availability)
+  ) : scopedBuildCommands.length > 0 ? runMultiCommandBuildGate(variantPath, changedFiles, baselineHealthy, scopedBuildCommands, {
+    baselineErrorKeys: options?.baselineTypecheck?.errorKeys,
+    typecheckExecutable: options?.baselineTypecheck?.typecheckExecutable,
+    abortSignal: options?.abortSignal,
+    timeoutMs: BUILD_CHANNEL_DEFAULT_TIMEOUT_MS
+  }) : runBuildGate(variantPath, changedFiles, baselineHealthy, {
+    baselineErrorKeys: options?.baselineTypecheck?.errorKeys,
+    typecheckExecutable: options?.baselineTypecheck?.typecheckExecutable,
+    abortSignal: options?.abortSignal,
+    command: scopedBuildCommand
+  });
+  const lintPromise = !runLintGateEnabled ? Promise.resolve(null) : !lintChannelRelevant ? Promise.resolve({ kind: "unavailable", gate: unavailableScopedLintGate() }) : scopedLintCommands.length > 0 ? runMultiCommandLintGate(variantPath, scopedLintCommands, {
+    abortSignal: options?.abortSignal,
+    timeoutMs: resolveLintGateTimeoutMs()
+  }).then((gate) => ({ kind: "aggregated", gate })) : runLintOnDiffWithArtifacts(variantPath, {
+    timeoutMs: resolveLintGateTimeoutMs(),
+    abortSignal: options?.abortSignal,
+    command: scopedLintCommand
+  }).then((artifact) => ({ kind: "artifact", artifact }));
+  const testGatePromise = variant && shouldRunTestGate ? !testChannelRelevant ? Promise.resolve(unavailableScopedTestGate()) : runTestGate(variant, variantPath, {
+    enabled: true,
+    mode: options?.testGateMode ?? "touched",
+    abortSignal: options?.abortSignal
+  }) : void 0;
+  const [requirementGate, buildGate, lintOutcome, testGate] = await Promise.all([
+    requirementPromise,
+    buildPromise,
+    lintPromise,
+    testGatePromise ?? Promise.resolve(void 0)
+  ]);
+  let lintGate;
+  if (lintOutcome) {
+    if (lintOutcome.kind === "aggregated" || lintOutcome.kind === "unavailable") {
+      lintGate = lintOutcome.gate;
+    } else {
+      const lintArtifact = lintOutcome.artifact;
+      lintGate = {
+        passed: lintArtifactPassed(lintArtifact),
+        errorCount: lintArtifact.result?.errorCount ?? 0,
+        warningCount: lintArtifact.result?.warningCount ?? 0,
+        filesWithIssues: lintArtifact.result?.filesWithIssues ?? [],
+        exitCode: lintArtifact.exitCode,
+        command: lintArtifact.command,
+        durationMs: lintArtifact.durationMs,
+        verificationCoverage: lintArtifact.verificationCoverage
+      };
+    }
+  }
+  const buildPassed = buildGate.signal === "pass";
+  const lintPassed = lintGate?.passed ?? false;
+  if (lintGate && lintGate.exitCode > 1) {
+    console.warn(
+      `[pre-score-gates] Lint tool error (exit ${lintGate.exitCode}) - treating as unknown`
+    );
+  }
+  const isEligible = true;
+  const diagnosticReason = explicitTestRequirement && (!testGate || testGate.testStatus === "not_run") ? "telemetry: explicit test requirement not met: no tests run" : void 0;
+  return {
+    requirementGate,
+    buildGate,
+    lintGate,
+    testGate,
+    buildPassed,
+    lintPassed,
+    isEligible,
+    diagnosticReason,
+    verificationCoverage: {
+      build: buildGate.verificationCoverage ?? {
+        status: buildGate.signal === "pass" ? "verified" : "partially_verified",
+        command: buildGate.command
+      },
+      lint: lintGate?.verificationCoverage ?? {
+        status: runLintGateEnabled ? "unverified" : "skipped_not_relevant",
+        reason: runLintGateEnabled ? "Lint gate returned no artifact." : "Lint gate was disabled."
+      },
+      ...testGate ? {
+        test: buildTestVerificationCoverage(testGate)
+      } : {}
+    }
+  };
+}
+function hasExplicitTestExecutionRequirement(requirements) {
+  if (!requirements || requirements.length === 0) {
+    return false;
+  }
+  const rebalanceEnabled = JUDGE_FEATURE_FLAGS.TEST_SIGNAL_REBALANCE === "on";
+  for (const req of requirements) {
+    const text = req.description.toLowerCase();
+    if (!rebalanceEnabled) {
+      const legacyPatterns = [
+        /\b\d+\s+tests?\b/i,
+        // "4 tests", "1 test"
+        /\btest cases?\b/i,
+        // "test case", "test cases"
+        /\btest files?\b/i,
+        // "test file", "test files"
+        /\bwrite tests?\b/i,
+        // "write tests"
+        /\badd tests?\b/i,
+        // "add tests"
+        /\bcreate tests?\b/i,
+        // "create tests"
+        /\bimplement tests?\b/i
+        // "implement tests"
+      ];
+      if (legacyPatterns.some((pattern) => pattern.test(text))) {
+        return true;
+      }
+      if (req.metadata?.files && req.metadata.files.length > 0) {
+        const hasTestFile = req.metadata.files.some((file) => isProjectTestPath(file));
+        if (hasTestFile) {
+          return true;
+        }
+      }
+      continue;
+    }
+    if (req.type === "tests" && (req.metadata?.testRequirementMode === "run" || req.metadata?.testRequirementMode === "pass")) {
+      return true;
+    }
+    const strictPatterns = [
+      /\btests?\s+(?:must|should|need(?:s)?|has\s+to|required\s+to)\s+pass\b/i,
+      /\bensure\s+(?:the\s+)?tests?\s+pass\b/i,
+      /\ball\s+tests?\s+pass(?:ing)?\b/i,
+      /\b(run|execute|verify|validate)\s+(?:the\s+)?tests?\b/i,
+      /\btests?\s+(?:must|should|need(?:s)?|has\s+to|required\s+to)\s+run\b/i,
+      /\btest\s+suite\s+(?:must|should|need(?:s)?|has\s+to|required\s+to)\s+pass\b/i,
+      /\btest\s+suite\s+(?:must|should|need(?:s)?|has\s+to|required\s+to)\s+run\b/i
+    ];
+    if (strictPatterns.some((pattern) => pattern.test(text))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/core/types/percent-score.ts
+var SCORE_MIN = 0;
+var SCORE_MAX = 100;
+function createPercentScore(value, context) {
+  if (!Number.isFinite(value)) {
+    throw new Error(`${context || "PercentScore"} must be a finite number, received ${value}`);
+  }
+  if (value < SCORE_MIN || value > SCORE_MAX) {
+    throw new Error(
+      `${context || "PercentScore"} must be between ${SCORE_MIN} and ${SCORE_MAX}, received ${value}`
+    );
+  }
+  return value;
+}
+function percentScoreToNumber(score) {
+  return score;
+}
+var PERCENT_SCORES = {
+  ZERO: createPercentScore(0, "constant"),
+  QUARTER: createPercentScore(25, "constant"),
+  HALF: createPercentScore(50, "constant"),
+  THREE_QUARTERS: createPercentScore(75, "constant"),
+  FULL: createPercentScore(100, "constant"),
+  DEFAULT_THRESHOLD: createPercentScore(60, "constant"),
+  HIGH_CONFIDENCE: createPercentScore(80, "constant"),
+  MAXIMUM_CONFIDENCE: createPercentScore(95, "constant")
+};
+
+// src/core/judge/structural-risk-scanner.ts
+var FUNCTION_DECLARATION_PATTERN = /^\s*(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/;
+var METHOD_DECLARATION_PATTERN = /^\s*(?:(?:public|private|protected|static|readonly|override|async|get|set)\s+)*([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*(?::[^{]+)?\s*\{/;
+var ARROW_FUNCTION_PATTERN = /^\s*(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>\s*\{/;
+var METHOD_KEYWORDS = /* @__PURE__ */ new Set(["if", "for", "while", "switch", "catch"]);
+var STRUCTURAL_RISK_APPLICABLE_LANGUAGES = /* @__PURE__ */ new Set([
+  "typescript",
+  "javascript",
+  "node"
+]);
+function isStructuralRiskApplicableLanguage(language) {
+  return language !== null && STRUCTURAL_RISK_APPLICABLE_LANGUAGES.has(language);
+}
+function resolveApplicability(applicableCount, unsupportedSourceCount) {
+  if (applicableCount === 0 && unsupportedSourceCount === 0) return "unknown";
+  if (applicableCount > 0 && unsupportedSourceCount === 0) return "applicable";
+  if (applicableCount === 0 && unsupportedSourceCount > 0) return "not_applicable";
+  return "mixed";
+}
+function scanDiffForStructuralRisks(diffText) {
+  if (!diffText || diffText.trim().length === 0) {
+    return emptyResult("unknown");
+  }
+  const sections = parseFileSections(diffText);
+  if (sections.length === 0) {
+    return emptyResult("unknown");
+  }
+  const findings = [];
+  const languagesSeen = /* @__PURE__ */ new Set();
+  let applicableCount = 0;
+  let unsupportedSourceCount = 0;
+  for (const section of sections) {
+    const language = languageForProjectPath(section.path);
+    if (language === null || language === "docs" || language === "unknown") {
+      continue;
+    }
+    languagesSeen.add(language);
+    if (!isStructuralRiskApplicableLanguage(language)) {
+      unsupportedSourceCount += 1;
+      continue;
+    }
+    applicableCount += 1;
+    findings.push(...detectSelfRecursiveCalls(section));
+    findings.push(...detectEmptyCatchBlocks(section));
+    findings.push(...detectUnreachableAfterReturn(section));
+    findings.push(...detectSwitchFallthrough(section));
+  }
+  const criticalCount = findings.filter((finding) => finding.severity === "critical").length;
+  const majorCount = findings.filter((finding) => finding.severity === "major").length;
+  const minorCount = findings.filter((finding) => finding.severity === "minor").length;
+  const applicability = resolveApplicability(applicableCount, unsupportedSourceCount);
+  return {
+    findings,
+    criticalCount,
+    majorCount,
+    minorCount,
+    hasCritical: criticalCount > 0,
+    applicability,
+    languagesSeen: [...languagesSeen]
+  };
+}
+function emptyResult(applicability = "unknown") {
+  return {
+    findings: [],
+    criticalCount: 0,
+    majorCount: 0,
+    minorCount: 0,
+    hasCritical: false,
+    applicability,
+    languagesSeen: []
+  };
+}
+function parseFileSections(diffText) {
+  const lines = diffText.replace(/\r\n/g, "\n").split("\n");
+  const sections = [];
+  let current = null;
+  let currentNewLine = 0;
+  const flush = () => {
+    if (current) {
+      sections.push(current);
+      current = null;
+    }
+  };
+  for (const line of lines) {
+    if (line.startsWith("diff --git ")) {
+      flush();
+      const paths = parseDiffGitHeaderPaths(line);
+      const path3 = paths?.bPath ?? paths?.aPath ?? line.replace(/^diff --git\s+/, "");
+      current = {
+        path: normalizePath(path3),
+        index: sections.length,
+        text: `${line}
+`,
+        addedLines: []
+      };
+      currentNewLine = 0;
+      continue;
+    }
+    if (!current) continue;
+    current.text += `${line}
+`;
+    const hunkMatch = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+    if (hunkMatch) {
+      currentNewLine = Number(hunkMatch[1] ?? "0");
+      continue;
+    }
+    if (line.startsWith("+++ ") || line.startsWith("--- ")) continue;
+    if (line.startsWith("+")) {
+      current.addedLines.push({
+        line: currentNewLine > 0 ? currentNewLine : null,
+        text: line.slice(1)
+      });
+      currentNewLine += 1;
+      continue;
+    }
+    if (line.startsWith("-")) {
+      continue;
+    }
+    if (line.startsWith(" ")) {
+      currentNewLine += 1;
+    }
+  }
+  flush();
+  return sections;
+}
+function detectSelfRecursiveCalls(section) {
+  const findings = [];
+  const blocks = extractFunctionBlocks(section);
+  for (const block of blocks) {
+    const nameEscaped = escapeRegex(block.name);
+    const selfCallPattern = new RegExp(
+      `(?<![.\\w$])(?:return\\s+)?(?:this\\.)?${nameEscaped}\\s*\\(`
+    );
+    const selfCallIndex = block.lines.findIndex((line, index) => {
+      if (index === 0) return false;
+      const text = line.text.trim();
+      if (!text || text.startsWith("//")) return false;
+      return selfCallPattern.test(text);
+    });
+    if (selfCallIndex < 0) continue;
+    const hasBaseCase = hasBaseCaseBeforeRecursiveCall(block.lines, selfCallIndex);
+    if (hasBaseCase) continue;
+    const selfCallLine = block.lines[selfCallIndex];
+    findings.push({
+      severity: "critical",
+      kind: "self_recursive_call",
+      summary: `Self-referential call detected in ${block.name}() without clear termination condition`,
+      filePath: block.filePath,
+      line: selfCallLine?.line ?? void 0,
+      evidence: selfCallLine?.text.trim()
+    });
+  }
+  return findings;
+}
+function extractFunctionBlocks(section) {
+  const blocks = [];
+  let active;
+  for (const line of section.addedLines) {
+    const text = line.text;
+    const signatureName = detectFunctionName(text);
+    if (!active && signatureName) {
+      const open2 = countChar(text, "{");
+      const close2 = countChar(text, "}");
+      active = {
+        name: signatureName,
+        braceDepth: open2 - close2,
+        sawOpeningBrace: open2 > 0,
+        lines: [line]
+      };
+      if (active.sawOpeningBrace && active.braceDepth <= 0) {
+        blocks.push({
+          name: active.name,
+          filePath: section.path,
+          lines: active.lines
+        });
+        active = void 0;
+      }
+      continue;
+    }
+    if (!active) continue;
+    active.lines.push(line);
+    const open = countChar(text, "{");
+    const close = countChar(text, "}");
+    if (open > 0) active.sawOpeningBrace = true;
+    active.braceDepth += open - close;
+    if (active.sawOpeningBrace && active.braceDepth <= 0) {
+      blocks.push({
+        name: active.name,
+        filePath: section.path,
+        lines: active.lines
+      });
+      active = void 0;
+    }
+  }
+  if (active && active.lines.length > 0) {
+    blocks.push({
+      name: active.name,
+      filePath: section.path,
+      lines: active.lines
+    });
+  }
+  return blocks;
+}
+function detectFunctionName(line) {
+  const declaration = line.match(FUNCTION_DECLARATION_PATTERN);
+  if (declaration?.[1]) return declaration[1];
+  const arrow = line.match(ARROW_FUNCTION_PATTERN);
+  if (arrow?.[1]) return arrow[1];
+  const method = line.match(METHOD_DECLARATION_PATTERN);
+  if (method?.[1]) {
+    const candidate = method[1];
+    if (!METHOD_KEYWORDS.has(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function hasBaseCaseBeforeRecursiveCall(lines, recursiveCallIndex) {
+  const prior = lines.slice(0, recursiveCallIndex + 1).map((line) => line.text.trim());
+  for (let i = 0; i < prior.length; i += 1) {
+    const text = prior[i];
+    if (!text) continue;
+    if (/\bif\s*\(/.test(text) && (/\breturn\b/.test(text) || /\bthrow\b/.test(text) || /\bbreak\b/.test(text))) {
+      return true;
+    }
+    if (/\bif\s*\(/.test(text) && i + 1 < prior.length) {
+      const next = prior[i + 1] ?? "";
+      if (/\breturn\b/.test(next) || /\bthrow\b/.test(next)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function detectEmptyCatchBlocks(section) {
+  const findings = [];
+  const lines = section.addedLines;
+  for (let i = 0; i < lines.length; i += 1) {
+    const current = lines[i];
+    if (!current) continue;
+    const text = current.text;
+    if (/catch\s*\([^)]*\)\s*{\s*}/.test(text)) {
+      findings.push({
+        severity: "major",
+        kind: "empty_catch",
+        summary: "Empty catch block detected",
+        filePath: section.path,
+        line: current.line ?? void 0,
+        evidence: text.trim()
+      });
+      continue;
+    }
+    if (!/catch\s*\([^)]*\)\s*{/.test(text)) continue;
+    let depth = countChar(text, "{") - countChar(text, "}");
+    const blockLines = [text];
+    let j = i + 1;
+    for (; j < lines.length && depth > 0; j += 1) {
+      const candidate = lines[j];
+      if (!candidate) break;
+      blockLines.push(candidate.text);
+      depth += countChar(candidate.text, "{") - countChar(candidate.text, "}");
+    }
+    const meaningful = blockLines.map((line) => line.trim()).filter(
+      (line) => line.length > 0 && line !== "{" && line !== "}" && !line.startsWith("//") && !line.startsWith("/*") && !line.startsWith("*") && !line.startsWith("catch")
+    );
+    if (meaningful.length === 0) {
+      findings.push({
+        severity: "major",
+        kind: "empty_catch",
+        summary: "Catch block swallows errors without handling",
+        filePath: section.path,
+        line: current.line ?? void 0,
+        evidence: current.text.trim()
+      });
+    }
+    i = j - 1;
+  }
+  return findings;
+}
+function detectUnreachableAfterReturn(section) {
+  const findings = [];
+  const blocks = extractFunctionBlocks(section);
+  for (const block of blocks) {
+    for (let i = 0; i < block.lines.length - 1; i += 1) {
+      const current = block.lines[i];
+      if (!current) continue;
+      const currentText = current.text.trim();
+      if (!/^(return|throw)\b/.test(currentText)) continue;
+      const currentIndent = indentation(current.text);
+      const next = findNextMeaningfulLine(block.lines, i + 1);
+      if (!next) continue;
+      const nextIndent = indentation(next.text);
+      const nextTrimmed = next.text.trim();
+      if (nextIndent === currentIndent && !nextTrimmed.startsWith("}") && !nextTrimmed.startsWith("else") && !nextTrimmed.startsWith("case ") && !nextTrimmed.startsWith("default:")) {
+        findings.push({
+          severity: "minor",
+          kind: "unreachable_after_return",
+          summary: "Possible unreachable code immediately after unconditional return/throw",
+          filePath: block.filePath,
+          line: next.line ?? void 0,
+          evidence: nextTrimmed
+        });
+      }
+    }
+  }
+  return findings;
+}
+function detectSwitchFallthrough(section) {
+  const findings = [];
+  const lines = section.addedLines;
+  let inSwitch = false;
+  let switchDepth = 0;
+  let caseStart = null;
+  let caseBody = [];
+  const flushCase = () => {
+    if (!caseStart) {
+      caseBody = [];
+      return;
+    }
+    const hasExplicitFlowEnd = caseBody.some(
+      (line) => /\b(break|return|throw|continue)\b/.test(line)
+    );
+    const hasFallthroughAnnotation = caseBody.some((line) => /fall.?through/i.test(line));
+    const hasExecutableContent = caseBody.some((line) => {
+      const trimmed = line.trim();
+      return trimmed.length > 0 && !trimmed.startsWith("//") && trimmed !== "{" && trimmed !== "}";
+    });
+    if (!hasExplicitFlowEnd && !hasFallthroughAnnotation && hasExecutableContent) {
+      findings.push({
+        severity: "major",
+        kind: "switch_fallthrough",
+        summary: "Switch case may fall through without break/return/throw",
+        filePath: section.path,
+        line: caseStart.line ?? void 0,
+        evidence: caseStart.text.trim()
+      });
+    }
+    caseStart = null;
+    caseBody = [];
+  };
+  for (const line of lines) {
+    const text = line.text;
+    const trimmed = text.trim();
+    if (!inSwitch && /\bswitch\s*\(/.test(trimmed)) {
+      inSwitch = true;
+      switchDepth = countChar(trimmed, "{") - countChar(trimmed, "}");
+      continue;
+    }
+    if (!inSwitch) continue;
+    switchDepth += countChar(trimmed, "{") - countChar(trimmed, "}");
+    if (switchDepth <= 0) {
+      flushCase();
+      inSwitch = false;
+      switchDepth = 0;
+      continue;
+    }
+    if (/^(case\b.+:|default:)/.test(trimmed)) {
+      flushCase();
+      caseStart = line;
+      continue;
+    }
+    if (caseStart) {
+      caseBody.push(trimmed);
+    }
+  }
+  flushCase();
+  return findings;
+}
+function findNextMeaningfulLine(lines, start) {
+  for (let i = start; i < lines.length; i += 1) {
+    const candidate = lines[i];
+    if (!candidate) continue;
+    const trimmed = candidate.text.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    return candidate;
+  }
+  return null;
+}
+function normalizePath(path3) {
+  return path3.replace(/\\/g, "/").replace(/^\.?\//, "").trim();
+}
+function countChar(text, char) {
+  let count = 0;
+  for (const c of text) {
+    if (c === char) count += 1;
+  }
+  return count;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function indentation(line) {
+  const match = line.match(/^\s*/);
+  return match?.[0].length ?? 0;
+}
+
+// src/core/judge/ac-compliance-scanner.ts
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function extractAddedDiffBody(diffText) {
+  if (!diffText) return "";
+  const lines = diffText.split("\n");
+  let sawUnifiedDiffHeader = false;
+  const addedLines = [];
+  for (const line of lines) {
+    if (line.startsWith("diff --git ")) {
+      sawUnifiedDiffHeader = true;
+      continue;
+    }
+    if (line.startsWith("@@") || line.startsWith("+++ ") || line.startsWith("--- ")) {
+      continue;
+    }
+    if (line.startsWith("+")) {
+      addedLines.push(line.slice(1));
+    }
+  }
+  if (addedLines.length === 0 && !sawUnifiedDiffHeader) {
+    return diffText.trim();
+  }
+  return addedLines.join("\n").trim();
+}
+function extractKeySymbols(acText) {
+  const camelCase = acText.match(/\b[a-z][a-zA-Z0-9]*[A-Z][a-zA-Z0-9]*\b/g) ?? [];
+  const pascalCase = acText.match(/\b[A-Z][a-z]+(?:[A-Z][a-z]+)+\b/g) ?? [];
+  const backtickTerms = (acText.match(/`([^`]+)`/g) ?? []).map((s) => s.replace(/`/g, ""));
+  const snakeCase = acText.match(/\b[a-z][a-z0-9]*(?:_[a-z0-9]+)+\b/g) ?? [];
+  const symbolPool = backtickTerms.length > 0 ? backtickTerms : [.../* @__PURE__ */ new Set([...camelCase, ...pascalCase, ...snakeCase])];
+  const combined = [...new Set(symbolPool)];
+  return combined.filter(
+    (s) => s.length >= 4 && !/^(this|that|when|then|from|with|must|have|each|only)$/i.test(s)
+  );
+}
+function evaluateACComplianceItems(contract, variant) {
+  if (!contract) return [];
+  const items = [
+    ...contract.mustHaves.map((item) => ({ item, source: "MUST" })),
+    ...contract.acceptanceCriteria.map((item) => ({ item, source: "AC" }))
+  ].filter(({ item }) => item.verification !== "gate");
+  if (items.length === 0) return [];
+  const addedDiffBody = extractAddedDiffBody(extractDiffText(variant));
+  const normalizedAddedDiffBody = addedDiffBody.toLowerCase();
+  const symbolRegexCache = /* @__PURE__ */ new Map();
+  const getSymbolRegex = (sym) => {
+    let regex = symbolRegexCache.get(sym);
+    if (!regex) {
+      regex = new RegExp(`\\b${escapeRegExp(sym)}\\b`, "i");
+      symbolRegexCache.set(sym, regex);
+    }
+    return regex;
+  };
+  const results = [];
+  for (const { item, source } of items) {
+    const extractedSymbols = extractKeySymbols(item.text);
+    const probeTerms = extractedSymbols.length > 0 ? extractedSymbols : [item.text.replace(/\s+/g, " ").trim()];
+    const matchedSymbols = probeTerms.filter((sym) => {
+      if (!sym) return false;
+      if (!normalizedAddedDiffBody) return false;
+      return getSymbolRegex(sym).test(addedDiffBody);
+    });
+    const status = matchedSymbols.length === 0 ? "NOT FOUND" : matchedSymbols.length === probeTerms.length ? "FOUND" : "PARTIAL";
+    results.push({
+      source,
+      itemText: item.text,
+      status,
+      symbols: probeTerms,
+      matchedSymbols
+    });
+  }
+  return results;
+}
+function buildACComplianceSection(contract, variant) {
+  const results = evaluateACComplianceItems(contract, variant);
+  if (results.length === 0) return "";
+  const lines = ["**AC Compliance Scan** (automated \u2014 presence/absence only):"];
+  for (const result of results) {
+    lines.push(
+      `- [${result.status}] [${result.source}] ${result.itemText} (scanned for: ${result.symbols.join(", ")}; matched: ${result.matchedSymbols.join(", ") || "none"})`
+    );
+  }
+  return lines.join("\n");
+}
+var BUGFIX_KEYWORD_PATTERN = /\b(fix|bug|patch|repair|resolve)\b/i;
+var PARSING_VALIDATION_SYMBOL_PATTERN = /\b(split|parse|validate|normalize|canonical|isValid|isCanonical|formatVariantIdentifier|parseVariantIdentifier|regex|regexp|matchAll?)\b/i;
+function variantHasParsingValidationChanges(variant) {
+  const addedDiffBody = extractAddedDiffBody(extractDiffText(variant));
+  if (!addedDiffBody) return false;
+  return PARSING_VALIDATION_SYMBOL_PATTERN.test(addedDiffBody);
+}
+function requiresInputSimulationCheck(variants, taskPrompt, taskKind) {
+  const isBugfix = taskKind === "bugfix" || BUGFIX_KEYWORD_PATTERN.test(taskPrompt);
+  if (!isBugfix) return false;
+  return variants.some((variant) => variantHasParsingValidationChanges(variant));
+}
+
+// src/core/judge/ai-judge-prompt-3bucket.ts
+var MAX_DELIVERABLE_EXCERPT_CHARS = 16e4;
+var MAX_DIFF_EXCERPT_CHARS = 16e4;
+var MAX_TOTAL_PROMPT_CHARS = 105e4;
+var FIXED_PROMPT_OVERHEAD_CHARS = 4e4;
+var PER_VARIANT_PROMPT_OVERHEAD_CHARS = 6e3;
+var MIN_TOTAL_EXCERPT_CHARS = 5e4;
+var MAX_EVIDENCE_CANDIDATES = 28;
+var MAX_FILE_INVENTORY_FILES = 40;
+var PROMPT_ORDER_V1_EVIDENCE_MULTIPLIER = 1.5;
+var PROMPT_ORDER_V1_MAX_EVIDENCE_CANDIDATES = 40;
+var MAX_POETIC_COMPLETION_REASON_CHARS = 1e3;
+function computePromptOrderEvidenceCandidateLimit(baseLimit, promptOrderMode) {
+  const normalizedBase = Math.max(1, Math.floor(baseLimit || 1));
+  if (promptOrderMode !== "experimental") return normalizedBase;
+  return Math.max(
+    normalizedBase,
+    Math.min(
+      PROMPT_ORDER_V1_MAX_EVIDENCE_CANDIDATES,
+      Math.ceil(normalizedBase * PROMPT_ORDER_V1_EVIDENCE_MULTIPLIER)
+    )
+  );
+}
+function applyTotalBudgetCap(caps, variantCount) {
+  const count = Math.max(1, variantCount);
+  const totalOverhead = FIXED_PROMPT_OVERHEAD_CHARS + PER_VARIANT_PROMPT_OVERHEAD_CHARS * count;
+  const excerptBudgetCap = Math.max(
+    MIN_TOTAL_EXCERPT_CHARS,
+    MAX_TOTAL_PROMPT_CHARS - totalOverhead
+  );
+  const totalExcerptBudget = (caps.maxDeliverableExcerptChars + caps.maxDiffExcerptChars) * count;
+  if (totalExcerptBudget <= excerptBudgetCap) return caps;
+  const scale = excerptBudgetCap / totalExcerptBudget;
+  return {
+    maxDeliverableExcerptChars: Math.max(
+      1e3,
+      Math.floor(caps.maxDeliverableExcerptChars * scale)
+    ),
+    maxDiffExcerptChars: Math.max(1e3, Math.floor(caps.maxDiffExcerptChars * scale)),
+    maxEvidenceCandidates: caps.maxEvidenceCandidates,
+    maxFileInventoryFiles: caps.maxFileInventoryFiles
+  };
+}
+function computeAdaptiveJudgePromptBudgetCaps(variantCount) {
+  const count = Math.max(1, Math.floor(variantCount || 1));
+  let caps;
+  if (count >= 10) {
+    caps = {
+      maxDeliverableExcerptChars: 4e4,
+      maxDiffExcerptChars: 4e4,
+      maxEvidenceCandidates: 12,
+      maxFileInventoryFiles: 12
+    };
+  } else if (count >= 6) {
+    caps = {
+      maxDeliverableExcerptChars: 8e4,
+      maxDiffExcerptChars: 8e4,
+      maxEvidenceCandidates: 16,
+      maxFileInventoryFiles: 16
+    };
+  } else if (count >= 4) {
+    caps = {
+      maxDeliverableExcerptChars: 13e4,
+      maxDiffExcerptChars: 13e4,
+      maxEvidenceCandidates: 20,
+      maxFileInventoryFiles: 20
+    };
+  } else {
+    caps = {
+      maxDeliverableExcerptChars: MAX_DELIVERABLE_EXCERPT_CHARS,
+      maxDiffExcerptChars: MAX_DIFF_EXCERPT_CHARS,
+      maxEvidenceCandidates: MAX_EVIDENCE_CANDIDATES,
+      maxFileInventoryFiles: MAX_FILE_INVENTORY_FILES
+    };
+  }
+  return applyTotalBudgetCap(caps, count);
+}
+function buildTruncationNote(fullChars, shownChars, label) {
+  if (fullChars <= shownChars) return "";
+  const pct = (shownChars / fullChars * 100).toFixed(0);
+  return `[${label}: showing ${shownChars.toLocaleString()} of ${fullChars.toLocaleString()} chars (${pct}%)]`;
+}
+function normalizeEvidenceTextForMatch(text) {
+  return text.replace(/\r\n/g, "\n").replace(/[“”]/g, '"').replace(/[‘’]/g, "'").replace(/[–—]/g, "-").replace(/\s+/g, " ").trim();
+}
+function evidenceQuoteMatchesExcerpt(excerpt, quote) {
+  if (typeof quote !== "string") return false;
+  const trimmed = quote.trim();
+  if (trimmed.length === 0) return false;
+  const canonicalExcerpt = excerpt.replace(/\r\n/g, "\n");
+  if (canonicalExcerpt.includes(trimmed.replace(/\r\n/g, "\n"))) return true;
+  const normalizedExcerpt = normalizeEvidenceTextForMatch(excerpt);
+  const normalizedQuote = normalizeEvidenceTextForMatch(quote);
+  if (normalizedQuote.length === 0) return false;
+  return normalizedExcerpt.includes(normalizedQuote);
+}
+function estimatePromptTokens(chars) {
+  return Math.max(0, charsToTokens(chars));
+}
+function metricFromText(text) {
+  const chars = text.length;
+  return { chars, estimatedTokens: estimatePromptTokens(chars) };
+}
+function metricFromChars(chars) {
+  const safeChars = Math.max(0, Math.floor(chars));
+  return { chars: safeChars, estimatedTokens: estimatePromptTokens(safeChars) };
+}
+var DIRECT_IMPL_EVIDENCE_LABEL = "[direct implementation evidence]";
+var EXECUTOR_CLAIM_LABEL = "[executor claim]";
+function extractExecutorClaimText(variant) {
+  if (variant.worktreeDiff && variant.worktreeDiff.trim().length > 0) {
+    const { worktreeDiff: _omit, ...withoutDiff } = variant;
+    return sanitizeJudgeText(extractCleanStdout(withoutDiff)).trim();
+  }
+  return sanitizeJudgeText(extractCleanStdout(variant)).trim();
+}
+function extractDirectImplementationEvidence(variant) {
+  const diffCandidate = sanitizeJudgeText(extractDiffText(variant)).trim();
+  if (!diffCandidate) return "";
+  if (variant.worktreeDiff?.trim()) return diffCandidate;
+  return /^(?:diff --git |--- (?:a\/|\/dev\/null)|\+\+\+ (?:b\/|\/dev\/null))/m.test(diffCandidate) ? diffCandidate : "";
+}
+function sampleEvidenceLines(text, maxCount, candidateClipChars, compactMode, sourceLabel) {
+  if (!text || maxCount <= 0) return [];
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pushCandidate = (line, lineNo2) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    const clipped = trimmed.length > candidateClipChars ? `${trimmed.slice(0, candidateClipChars - 3)}...` : trimmed;
+    const normalizedKey = normalizeEvidenceTextForMatch(clipped).toLowerCase();
+    if (!normalizedKey) return;
+    if (seen.has(normalizedKey)) return;
+    seen.add(normalizedKey);
+    const body = compactMode ? `L${lineNo2}: ${clipped}` : clipped;
+    candidates.push(sourceLabel ? `${sourceLabel} ${body}` : body);
+  };
+  const allQualifying = [];
+  let lineNo = 0;
+  for (const line of text.split("\n")) {
+    lineNo += 1;
+    const trimmed = line.trim();
+    if (trimmed.length < 8) continue;
+    allQualifying.push({ line: trimmed, lineNo });
+  }
+  if (allQualifying.length === 0) return [];
+  if (allQualifying.length <= maxCount) {
+    for (const entry of allQualifying) {
+      pushCandidate(entry.line, entry.lineNo);
+    }
+  } else {
+    const step = allQualifying.length / maxCount;
+    for (let i = 0; i < maxCount; i++) {
+      const idx = Math.min(Math.floor(i * step), allQualifying.length - 1);
+      const entry = allQualifying[idx];
+      if (!entry) continue;
+      pushCandidate(entry.line, entry.lineNo);
+      if (candidates.length >= maxCount) break;
+    }
+  }
+  return candidates;
+}
+function buildVariantEvidenceCandidatesForJudge(variant, options) {
+  const analysisWithoutDiff = variant.executionIntent === "analysis" && !(typeof variant.worktreeDiff === "string" && variant.worktreeDiff.trim().length > 0);
+  const primaryStdout = sanitizeJudgeText(extractCleanStdout(variant)).trim();
+  const claimStdout = extractExecutorClaimText(variant);
+  const cleanedStdout = analysisWithoutDiff ? primaryStdout || claimStdout : claimStdout;
+  const diffText = analysisWithoutDiff ? "" : extractDirectImplementationEvidence(variant);
+  const maxEvidenceCandidates = Math.max(
+    1,
+    Math.floor(options?.maxEvidenceCandidates ?? MAX_EVIDENCE_CANDIDATES)
+  );
+  const compactMode = options?.compactMode === true;
+  const effectiveMaxEvidenceCandidates = compactMode ? Math.max(1, Math.min(4, maxEvidenceCandidates)) : maxEvidenceCandidates;
+  const candidateClipChars = compactMode ? 96 : 220;
+  if (analysisWithoutDiff) {
+    const primary = sampleEvidenceLines(
+      cleanedStdout || diffText,
+      effectiveMaxEvidenceCandidates,
+      candidateClipChars,
+      compactMode,
+      null
+    );
+    return primary.length > 0 ? primary : ["(none)"];
+  }
+  if (diffText.length === 0 && cleanedStdout.length > 0) {
+    const claims = sampleEvidenceLines(
+      cleanedStdout,
+      effectiveMaxEvidenceCandidates,
+      candidateClipChars,
+      compactMode,
+      compactMode ? null : EXECUTOR_CLAIM_LABEL
+    );
+    return claims.length > 0 ? claims : ["(none)"];
+  }
+  if (diffText.length > 0) {
+    const claimBudget = cleanedStdout.length > 0 ? Math.max(1, Math.floor(effectiveMaxEvidenceCandidates / 4)) : 0;
+    const diffBudget = Math.max(1, effectiveMaxEvidenceCandidates - claimBudget);
+    const candidates = sampleEvidenceLines(
+      diffText,
+      diffBudget,
+      candidateClipChars,
+      compactMode,
+      compactMode ? null : DIRECT_IMPL_EVIDENCE_LABEL
+    );
+    if (cleanedStdout.length > 0 && claimBudget > 0) {
+      const claims = sampleEvidenceLines(
+        cleanedStdout,
+        claimBudget,
+        candidateClipChars,
+        compactMode,
+        compactMode ? null : EXECUTOR_CLAIM_LABEL
+      );
+      for (const claim of claims) {
+        if (candidates.length >= effectiveMaxEvidenceCandidates) break;
+        candidates.push(claim);
+      }
+    }
+    return candidates.length > 0 ? candidates : ["(none)"];
+  }
+  if (compactMode && diffText.length > 0) {
+    const primary = sampleEvidenceLines(
+      diffText,
+      effectiveMaxEvidenceCandidates,
+      candidateClipChars,
+      compactMode,
+      null
+    );
+    return primary.length > 0 ? primary : ["(none)"];
+  }
+  return ["(none)"];
+}
+function stripWrappedQuoteChars(value) {
+  let trimmed = value.trim();
+  while (trimmed.length >= 2) {
+    const first = trimmed[0];
+    const last = trimmed[trimmed.length - 1];
+    const wraps = first === '"' && last === '"' || first === "'" && last === "'" || first === "`" && last === "`";
+    if (!wraps) break;
+    trimmed = trimmed.slice(1, -1).trim();
+  }
+  return trimmed;
+}
+function normalizePathForMatch(pathText) {
+  return pathText.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function extractEvidencePathReference(rawQuote) {
+  const normalized = stripWrappedQuoteChars(rawQuote).replace(/^file:\s*/i, "").trim();
+  if (!normalized) return null;
+  const fileRefMatch = normalized.match(
+    /^((?:[a-zA-Z]:[\\/])?[a-zA-Z0-9_.-]+(?:[\\/][a-zA-Z0-9_.-]+)+\.[a-zA-Z0-9]{1,8})(?::\d+(?::\d+)?)?(?:#L\d+(?:C\d+)?)?$/i
+  );
+  if (!fileRefMatch?.[1]) return null;
+  return normalizePathForMatch(fileRefMatch[1]);
+}
+function excerptContainsPathReference(excerpt, pathReference) {
+  const normalizedExcerpt = excerpt.replace(/\\/g, "/");
+  const candidates = /* @__PURE__ */ new Set([pathReference]);
+  const withoutDiffPrefix = pathReference.startsWith("a/") || pathReference.startsWith("b/") ? pathReference.slice(2) : pathReference;
+  candidates.add(withoutDiffPrefix);
+  candidates.add(`a/${withoutDiffPrefix}`);
+  candidates.add(`b/${withoutDiffPrefix}`);
+  for (const candidate of candidates) {
+    if (candidate && normalizedExcerpt.includes(candidate)) {
+      return true;
+    }
+  }
+  return false;
+}
+function evidenceQuoteIsValid(excerpt, candidates, quote) {
+  const raw = typeof quote === "string" ? quote.trim() : "";
+  if (!raw) return false;
+  const idMatch = raw.match(/^E(\d{1,2})$/i);
+  if (idMatch) {
+    const idx = Number(idMatch[1]);
+    if (!Number.isFinite(idx) || idx < 1 || idx > candidates.length) return false;
+    return true;
+  }
+  const pathReference = extractEvidencePathReference(raw);
+  if (pathReference) {
+    if (excerptContainsPathReference(excerpt, pathReference)) {
+      return true;
+    }
+    const candidateHasPath = candidates.some(
+      (candidate) => normalizeEvidenceTextForMatch(candidate).toLowerCase().includes(pathReference.toLowerCase())
+    );
+    if (candidateHasPath) {
+      return true;
+    }
+  }
+  const normalizedQuote = normalizeEvidenceTextForMatch(raw).toLowerCase();
+  if (!normalizedQuote) return false;
+  for (const candidate of candidates) {
+    if (normalizeEvidenceTextForMatch(candidate).toLowerCase() === normalizedQuote) return true;
+  }
+  if (normalizedQuote.replace(/\s+/g, "").length < 10) {
+    return false;
+  }
+  return evidenceQuoteMatchesExcerpt(excerpt, raw);
+}
+function sanitizeJudgeText(text) {
+  if (!text) return "";
+  let out = text.replace(/\uE200cite\uE202[^\uE201]*\uE201/g, "");
+  out = presentUntrustedJudgeEvidence(out);
+  out = out.split("\n").flatMap((line) => {
+    if (!line.includes('"type":"poetic_completion"')) return [line];
+    try {
+      const parsed = JSON.parse(line.trim());
+      if (parsed.type === "poetic_completion" && typeof parsed.reason === "string") {
+        const editIntent = typeof parsed.editIntent === "string" ? parsed.editIntent : "unknown";
+        const filesEdited = Array.isArray(parsed.filesEdited) ? parsed.filesEdited.length : 0;
+        const reason = sanitizePoeticCompletionReason(parsed.reason);
+        return [
+          `Poetic completion signal: editIntent=${editIntent}; filesEdited=${filesEdited}; reason=${reason}`
+        ];
+      }
+    } catch {
+    }
+    return [];
+  }).join("\n");
+  return out;
+}
+function sanitizePoeticCompletionReason(reason) {
+  const withoutControlChars = Array.from(reason).filter((char) => {
+    const code = char.charCodeAt(0);
+    return code === 9 || code === 10 || code === 13 || code >= 32 && code !== 127;
+  }).join("");
+  return truncateHeadTail(
+    redactSuspiciousJudgePromptPatterns(withoutControlChars),
+    MAX_POETIC_COMPLETION_REASON_CHARS
+  );
+}
+function truncateHeadTail(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  const marker = "\n...[truncated]...\n";
+  const remaining = maxChars - marker.length;
+  const head = Math.max(0, Math.floor(remaining * 0.6));
+  const tail = Math.max(0, remaining - head);
+  return `${text.slice(0, head)}${marker}${text.slice(Math.max(0, text.length - tail))}`;
+}
+function splitDiffByFile(text) {
+  const sections = [];
+  const diffPattern = /^diff --git a\/(.+?) b\//gm;
+  const starts = [];
+  for (; ; ) {
+    const match = diffPattern.exec(text);
+    if (!match) break;
+    const path3 = match[1];
+    if (!path3) continue;
+    starts.push({ path: path3, index: match.index });
+  }
+  if (starts.length === 0) {
+    const changedLines = text.split("\n").filter(
+      (line) => line.startsWith("+") && !line.startsWith("+++") || line.startsWith("-") && !line.startsWith("---")
+    ).length;
+    return [
+      {
+        path: "(single)",
+        text,
+        lineCount: text.split("\n").length,
+        changedLines,
+        originalIndex: 0
+      }
+    ];
+  }
+  for (let i = 0; i < starts.length; i++) {
+    const current = starts[i];
+    if (!current) continue;
+    const start = current.index;
+    const next = starts[i + 1];
+    const end = next ? next.index : text.length;
+    const sectionText = text.slice(start, end);
+    const changedLines = sectionText.split("\n").filter(
+      (line) => line.startsWith("+") && !line.startsWith("+++") || line.startsWith("-") && !line.startsWith("---")
+    ).length;
+    sections.push({
+      path: current.path,
+      text: sectionText,
+      lineCount: sectionText.split("\n").length,
+      changedLines,
+      originalIndex: i
+    });
+  }
+  return sections;
+}
+function truncateWithFileBoundaries(text, maxChars, options) {
+  if (text.length <= maxChars) return text;
+  const fileSections = splitDiffByFile(text);
+  if (fileSections.length <= 1) {
+    return truncateHeadTail(text, maxChars);
+  }
+  const priorityPaths = (options?.priorityPaths ?? []).map(
+    (path3) => normalizePathForMatch(path3).replace(/^(a|b)\//, "")
+  );
+  const rankedSections = [...fileSections].sort((left, right) => {
+    const leftPath = normalizePathForMatch(left.path).replace(/^(a|b)\//, "");
+    const rightPath = normalizePathForMatch(right.path).replace(/^(a|b)\//, "");
+    const leftPriority = priorityPaths.some(
+      (priority) => leftPath === priority || leftPath.endsWith(`/${priority}`)
+    ) ? 1 : 0;
+    const rightPriority = priorityPaths.some(
+      (priority) => rightPath === priority || rightPath.endsWith(`/${priority}`)
+    ) ? 1 : 0;
+    if (leftPriority !== rightPriority) return rightPriority - leftPriority;
+    const leftDensity = left.changedLines / Math.max(1, left.lineCount);
+    const rightDensity = right.changedLines / Math.max(1, right.lineCount);
+    if (leftDensity !== rightDensity) return rightDensity - leftDensity;
+    return left.originalIndex - right.originalIndex;
+  });
+  const included = [];
+  const omitted = [];
+  const summaryBudget = 200;
+  let remaining = maxChars - summaryBudget;
+  for (const section of rankedSections) {
+    if (section.text.length <= remaining) {
+      included.push(section.text);
+      remaining -= section.text.length;
+    } else if (included.length === 0) {
+      included.push(truncateHeadTail(section.text, remaining));
+      remaining = 0;
+    } else {
+      omitted.push({ path: section.path, lines: section.lineCount });
+    }
+  }
+  if (omitted.length > 0) {
+    const omittedSummary = `
+[${omitted.length} file(s) omitted: ${omitted.map((f) => `${f.path} (+${f.lines})`).join(", ")}]
+`;
+    included.push(omittedSummary);
+    if (priorityPaths.length > 0) {
+      const omittedPriority = omitted.filter((f) => {
+        const normalizedPath = normalizePathForMatch(f.path).replace(/^(a|b)\//, "");
+        return priorityPaths.some((p) => normalizedPath === p || normalizedPath.endsWith(`/${p}`));
+      });
+      if (omittedPriority.length > 0) {
+        included.push(
+          `
+[WARNING: ${omittedPriority.length} acceptance-criteria file(s) omitted due to size: ${omittedPriority.map((f) => f.path).join(", ")}. Evidence for these files is incomplete.]
+`
+        );
+      }
+    }
+  }
+  return included.join("");
+}
+function buildVariantDeliverableExcerptForJudge(variant, options) {
+  const analysisWithoutDiff = variant.executionIntent === "analysis" && !(typeof variant.worktreeDiff === "string" && variant.worktreeDiff.trim().length > 0);
+  const primaryStdout = sanitizeJudgeText(extractCleanStdout(variant)).trim();
+  const claimStdout = extractExecutorClaimText(variant);
+  const cleanedStdout = analysisWithoutDiff ? primaryStdout || claimStdout : claimStdout;
+  const diffText = analysisWithoutDiff ? "" : extractDirectImplementationEvidence(variant);
+  const maxDeliverableExcerptChars = Math.max(
+    1,
+    Math.floor(options?.maxDeliverableExcerptChars ?? MAX_DELIVERABLE_EXCERPT_CHARS)
+  );
+  const maxDiffExcerptChars = Math.max(
+    1,
+    Math.floor(options?.maxDiffExcerptChars ?? MAX_DIFF_EXCERPT_CHARS)
+  );
+  const truncation = {
+    outputFullChars: cleanedStdout.length,
+    outputShownChars: Math.min(cleanedStdout.length, maxDeliverableExcerptChars),
+    diffFullChars: diffText.length,
+    diffShownChars: Math.min(diffText.length, maxDiffExcerptChars)
+  };
+  const structuralRisks = scanDiffForStructuralRisks(diffText);
+  const priorityFiles = Array.from(
+    /* @__PURE__ */ new Set([
+      ...options?.priorityFiles ?? [],
+      ...buildVariantPriorityFiles(variant, structuralRisks)
+    ])
+  );
+  const timedOutWithPartialEdits = variant.timedOut === true && variant.partialEdits === true;
+  const parts = [];
+  if (diffText.length > 0) {
+    const diffLabel = timedOutWithPartialEdits ? "<<<DELIVERABLE EXCERPT: DIFF [PARTIAL/INCOMPLETE]>>>" : "<<<DELIVERABLE EXCERPT: DIFF>>>";
+    parts.push(
+      `${diffLabel}
+Source: direct implementation evidence
+${frameUntrustedJudgeEvidence(truncateWithFileBoundaries(diffText, maxDiffExcerptChars, { priorityPaths: priorityFiles }))}
+<<<END EXCERPT>>>`
+    );
+  }
+  if (cleanedStdout.length > 0) {
+    if (!analysisWithoutDiff) {
+      parts.push(
+        `<<<UNTRUSTED DELIVERABLE EXCERPT: PROVIDER OUTPUT>>>
+Source: executor claim (not implementation evidence)
+${frameUntrustedJudgeEvidence(truncateHeadTail(cleanedStdout, maxDeliverableExcerptChars))}
+<<<END UNTRUSTED EXCERPT>>>`
+      );
+    } else {
+      parts.push(
+        `<<<UNTRUSTED DELIVERABLE EXCERPT: PROVIDER OUTPUT>>>
+${frameUntrustedJudgeEvidence(truncateHeadTail(cleanedStdout, maxDeliverableExcerptChars))}
+<<<END UNTRUSTED EXCERPT>>>`
+      );
+    }
+  }
+  const text = parts.length > 0 ? parts.join("\n\n") : "<<<DELIVERABLE EXCERPT: NONE>>>\n(none)\n<<<END EXCERPT>>>";
+  return { text, truncation };
+}
+function buildVariantPriorityFiles(variant, structuralRisks) {
+  const priorities = /* @__PURE__ */ new Set();
+  for (const file of variant.testsExecuted?.filesTested ?? []) {
+    priorities.add(normalizePathForMatch(file).replace(/^(a|b)\//, ""));
+  }
+  for (const finding of structuralRisks.findings) {
+    if (finding.filePath) {
+      priorities.add(normalizePathForMatch(finding.filePath).replace(/^(a|b)\//, ""));
+    }
+  }
+  return Array.from(priorities);
+}
+function formatEmpiricalSignals(signals, variant) {
+  const lines = [];
+  lines.push("**Execution**:");
+  lines.push(`  success: ${signals.execution.success}`);
+  lines.push(`  emptyChanges: ${signals.execution.emptyChanges}`);
+  lines.push(`  timedOut: ${signals.execution.timedOut}`);
+  lines.push(`  partialEdits: ${signals.execution.partialEdits === true}`);
+  if (signals.execution.failureType) {
+    lines.push(`  failureType: ${signals.execution.failureType}`);
+  }
+  if (signals.execution.failureReason) {
+    lines.push(`  failureReason: ${signals.execution.failureReason}`);
+  }
+  if (signals.execution.timedOut && signals.execution.partialEdits) {
+    lines.push(
+      "  note: timed out after partial implementation; score partial credit from diff evidence"
+    );
+  }
+  lines.push(`  taskKind: ${signals.execution.taskKind}`);
+  if (signals.execution.gitTelemetryValidation?.valid === false) {
+    lines.push("  gitTelemetryValidation: failed");
+    for (const error of signals.execution.gitTelemetryValidation.errors.slice(0, 3)) {
+      lines.push(`    error: ${error}`);
+    }
+  }
+  if (signals.execution.targetIntegrityEvidence?.fabricatedTargets.length) {
+    const evidence = signals.execution.targetIntegrityEvidence;
+    lines.push("  targetIntegrityEvidence: fabricated FILE target(s) detected");
+    lines.push(`    fabricatedTargets: [${evidence.fabricatedTargets.join(", ")}]`);
+    lines.push(`    rawCompleteness: ${evidence.rawCompleteness}`);
+    lines.push(`    suggestedCompleteness: ${evidence.suggestedCompleteness}`);
+    lines.push(`    reason: ${evidence.reason}`);
+  }
+  if (signals.execution.testStatus) {
+    lines.push(`  testStatus (raw, pre-baseline): ${signals.execution.testStatus}`);
+  }
+  if (signals.execution.verificationStatusAdjusted) {
+    lines.push(
+      `  verificationStatus (adjusted, baseline-aware): ${signals.execution.verificationStatusAdjusted}`
+    );
+  }
+  const verificationIntent = signals.verificationIntent;
+  lines.push("\n**Verification Intent**:");
+  lines.push(`  expectation: ${verificationIntent?.type ?? "neither"}`);
+  lines.push(`  confidence: ${(verificationIntent?.confidence ?? 0).toFixed(2)}`);
+  if (verificationIntent?.evidence?.length) {
+    lines.push(`  evidence: [${verificationIntent.evidence.join(" | ")}]`);
+  }
+  if (verificationIntent?.overrideSource) {
+    lines.push(`  override: ${verificationIntent.overrideSource}`);
+  }
+  lines.push("\n**File Targets**:");
+  lines.push(`  fileTargets: [${signals.fileTargets.join(", ")}]`);
+  lines.push(`  changedFiles: [${signals.changedFiles.join(", ")}]`);
+  lines.push(`  targetCompliance: ${signals.targetCompliance}`);
+  if (signals.offTargetFiles.length > 0) {
+    lines.push(`  offTargetFiles: [${signals.offTargetFiles.join(", ")}]`);
+  }
+  if (signals.deliverableTargets && signals.deliverableTargets.length > 0) {
+    lines.push("\n**Deliverable Requirements**:");
+    lines.push(`  deliverableTargets: [${signals.deliverableTargets.join(", ")}]`);
+    lines.push(`  deliverableSatisfied: ${signals.deliverableSatisfied}`);
+    if (signals.deliverablePossibleCollision) {
+      lines.push(
+        '  warning: DELIVERABLE marker may have been a prose "Deliverables:" section (non-uppercase marker)'
+      );
+    }
+  }
+  const changedTestFiles = signals.changedFiles.filter((p) => isProjectTestPath(p));
+  if (changedTestFiles.length > 0) {
+    lines.push(`  changedTestFiles: [${changedTestFiles.join(", ")}]`);
+  }
+  lines.push("\n**Diff Stats**:");
+  lines.push(`  filesChanged: ${signals.diffStats.filesChanged}`);
+  lines.push(`  linesAdded: ${signals.diffStats.linesAdded}`);
+  lines.push(`  linesRemoved: ${signals.diffStats.linesRemoved}`);
+  if (signals.execution.workspaceEditsRequested > 0 || signals.execution.workspaceEditsApplied > 0) {
+    lines.push("\n**Workspace Edits**:");
+    lines.push(`  requested: ${signals.execution.workspaceEditsRequested}`);
+    lines.push(`  applied: ${signals.execution.workspaceEditsApplied}`);
+    if (signals.execution.ws007Count > 0) {
+      lines.push(`  ws007Rejected: ${signals.execution.ws007Count}`);
+    }
+    if (signals.execution.workspaceEditsApplied === 0 && (signals.diffStats.filesChanged > 0 || signals.diffStats.linesAdded > 0 || signals.diffStats.linesRemoved > 0)) {
+      lines.push(
+        "  note: JSONL applied=0 but git diff shows changes; treat as applied for evaluation"
+      );
+    } else if (signals.execution.workspaceEditsRequested > signals.execution.workspaceEditsApplied) {
+      lines.push("  note: partial workspace edits applied");
+    }
+    if (signals.execution.ws007Count > 10) {
+      lines.push(
+        `   HIGH WS-007 REJECTIONS (${signals.execution.ws007Count}): This variant's output may be incomplete. Many file writes were blocked by the empty-contents safety guard. Score the variant on what it delivered, but note potential handicap.`
+      );
+    }
+  }
+  if (signals.testMetrics) {
+    lines.push("\n**Test Metrics**:");
+    lines.push(`  totalTests: ${signals.testMetrics.totalTests}`);
+    lines.push(`  testQualityLevel: ${signals.testMetrics.testQualityLevel}`);
+    lines.push(`  testQualityScore: ${signals.testMetrics.testQualityScore}/15`);
+    lines.push(
+      `  commandPathTests: ${signals.testMetrics.commandPathTests.count} (confidence: ${signals.testMetrics.commandPathTests.confidence})`
+    );
+    lines.push(`  exitCodeAssertions: ${signals.testMetrics.exitCodeAssertions.count}`);
+    lines.push(`  stderrAssertions: ${signals.testMetrics.stderrAssertions.count}`);
+  }
+  if (signals.requirements?.found) {
+    lines.push("\n**Requirements**:");
+    if (signals.requirements.parseErrors.length > 0) {
+      lines.push(`  parseErrors: [${signals.requirements.parseErrors.join(" | ")}]`);
+    }
+    lines.push(`  compliant: ${signals.requirements.compliant}`);
+    lines.push(
+      `  satisfied: ${signals.requirements.satisfiedCount}/${signals.requirements.totalCount}`
+    );
+    lines.push(`  penalty: ${signals.requirements.penalty}`);
+    if (signals.requirements.violations.length > 0) {
+      lines.push(`  violations: [${signals.requirements.violations.join(" | ")}]`);
+    }
+    const total = signals.requirements.totalCount;
+    const satisfied = signals.requirements.satisfiedCount;
+    if (total > 0 && satisfied / total < 0.5) {
+      lines.push(
+        `   LOW COVERAGE: Only ${satisfied}/${total} requirements satisfied. Completeness score should reflect this gap.`
+      );
+    }
+  }
+  if (variant) {
+    const structuralRisks = scanDiffForStructuralRisks(sanitizeJudgeText(extractDiffText(variant)));
+    if (structuralRisks.findings.length > 0) {
+      lines.push("\n**Structural Risk Signals**:");
+      lines.push(
+        `  critical: ${structuralRisks.criticalCount}, major: ${structuralRisks.majorCount}, minor: ${structuralRisks.minorCount}`
+      );
+      for (const finding of structuralRisks.findings.slice(0, 3)) {
+        const displayPath = finding.filePath !== void 0 ? escapePathForJudgePromptDisplay(finding.filePath) : void 0;
+        const location = displayPath && finding.line ? `${displayPath}:${finding.line}` : displayPath ?? "unknown location";
+        lines.push(`  - ${finding.severity.toUpperCase()}: ${finding.summary} (${location})`);
+      }
+    }
+    const testFailureDetails = extractFailureDetailSnippet(variant, "test");
+    if (testFailureDetails) {
+      lines.push("\n**Test Failure Details**:");
+      lines.push(...testFailureDetails.split("\n").map((line) => `  ${line}`));
+    }
+    const buildFailureDetails = extractFailureDetailSnippet(variant, "build");
+    if (buildFailureDetails) {
+      lines.push("\n**Build Failure Details**:");
+      lines.push(...buildFailureDetails.split("\n").map((line) => `  ${line}`));
+    }
+  }
+  if (signals.testGate) {
+    lines.push("\n**Test Gate (Verified)**:");
+    lines.push(`  testStatus (raw): ${signals.testGate.testStatus}`);
+    lines.push(`  testsRun: ${signals.testGate.testsRun}`);
+    lines.push(`  testsPassed: ${signals.testGate.testsPassed}`);
+    lines.push(`  testsFailed: ${signals.testGate.testsFailed}`);
+    if (typeof signals.testGate.exitCode === "number") {
+      lines.push(`  exitCode: ${signals.testGate.exitCode}`);
+    }
+    if (signals.testGate.signalConsistency) {
+      lines.push(`  signalConsistency: ${signals.testGate.signalConsistency}`);
+    }
+  }
+  if (variant && hasVerificationEvidenceForQualityCard(variant, signals)) {
+    lines.push("");
+    lines.push(formatVerificationEvidenceQualitySummary(variant));
+  }
+  if (JUDGE_FEATURE_FLAGS.VARIANT_DIFFERENTIATION_SIGNALS === "on" && signals.scopeViolation && signals.scopeViolation.scopeViolationSeverity !== "none") {
+    const sv = signals.scopeViolation;
+    lines.push("\n**Scope Violation**:");
+    lines.push(`  severity: ${sv.scopeViolationSeverity}`);
+    lines.push(`  scopeSource: ${sv.scopeSource}`);
+    lines.push(`  outOfScopeRatio: ${sv.outOfScopeRatio.toFixed(2)}`);
+    if (sv.outOfScopeFiles.length > 0) {
+      lines.push(`  outOfScopeFiles: [${sv.outOfScopeFiles.slice(0, 5).join(", ")}]`);
+    }
+    if (sv.highRiskOutOfScope.length > 0) {
+      lines.push(`  highRiskOutOfScope: [${sv.highRiskOutOfScope.join(", ")}]`);
+    }
+  }
+  if (JUDGE_FEATURE_FLAGS.VARIANT_DIFFERENTIATION_SIGNALS === "on" && signals.coherenceCheck && !signals.coherenceCheck.coherent) {
+    lines.push("\n**Coherence Check**:");
+    lines.push(`  coherent: ${signals.coherenceCheck.coherent}`);
+    for (const issue of signals.coherenceCheck.issues) {
+      lines.push(`  - ${issue.check}: ${issue.detail}`);
+    }
+  }
+  return lines.join("\n");
+}
+function extractFailureDetailSnippet(variant, kind, maxChars = 500) {
+  const findings = variant.verification?.findings ?? [];
+  const matching = findings.filter((finding) => finding.kind === kind && typeof finding.outputTail === "string").map((finding) => finding.outputTail?.trim() ?? "").filter((output) => output.length > 0);
+  if (matching.length === 0) return null;
+  return clipSnippet(matching.join("\n"), maxChars);
+}
+function hasVerificationEvidenceForQualityCard(variant, signals) {
+  return Boolean(
+    variant.verification || variant.verificationLoop?.enabled || variant.testsExecuted || signals.buildGate || signals.testGate
+  );
+}
+function clipSnippet(text, maxChars = 500) {
+  if (typeof text !== "string") return null;
+  const trimmed = text.trim();
+  if (!trimmed) return null;
+  if (trimmed.length <= maxChars) return trimmed;
+  return `${trimmed.slice(0, maxChars)}...`;
+}
+function buildFileInventory(variant, options) {
+  const signals = variant.empiricalSignals;
+  if (!signals || signals.changedFiles.length === 0) return "";
+  const files = signals.changedFiles;
+  const maxFileInventoryFiles = Math.max(
+    1,
+    Math.floor(options?.maxFileInventoryFiles ?? MAX_FILE_INVENTORY_FILES)
+  );
+  const lines = [`**Files Changed (${files.length}):**`];
+  for (const f of files.slice(0, maxFileInventoryFiles)) {
+    lines.push(`  - ${f}`);
+  }
+  if (files.length > maxFileInventoryFiles) {
+    lines.push(`  - ... and ${files.length - maxFileInventoryFiles} more`);
+  }
+  return lines.join("\n");
+}
+function resolveAcceptanceCriteriaTargets(taskPrompt) {
+  const spec = parsePromptSpec(taskPrompt);
+  const inlineTargets = Array.from(taskPrompt.matchAll(/\bFILE:\s*([^\s]+)/gi)).map(
+    (m) => m[1] ?? ""
+  );
+  return Array.from(
+    new Set([...spec.fileConstraint?.targets ?? [], ...inlineTargets].filter(Boolean))
+  );
+}
+function buildAIPrompt3Bucket(variants, taskPrompt, taskKind, options) {
+  const variantSections = [];
+  const adaptiveBudgetCaps = computeAdaptiveJudgePromptBudgetCaps(variants.length);
+  const evaluationContext = resolveJudgeEvaluationContext(taskPrompt ?? "", {
+    evaluationContext: options?.evaluationContext,
+    variants
+  });
+  const spec = parsePromptSpec(taskPrompt ?? "");
+  const fileTargets = evaluationContext.fileTargets.length > 0 ? [...evaluationContext.fileTargets] : resolveAcceptanceCriteriaTargets(taskPrompt ?? "");
+  const evidenceTextByVariant = {};
+  const evidenceCandidatesByVariant = {};
+  const truncationByVariant = {};
+  const promptTelemetryByVariant = {};
+  const worktreePaths = options?.worktreePaths;
+  let contract = evaluationContext.taskContract;
+  if (!contract) {
+    try {
+      contract = extractTaskContract(taskPrompt ?? "", { validateQuotes: false });
+    } catch {
+    }
+  }
+  const hasContractItems = Boolean(
+    contract && (contract.mustHaves.length > 0 || contract.acceptanceCriteria.length > 0)
+  );
+  let hasAnyACComplianceScan = false;
+  for (const variant of variants) {
+    const signals = variant.empiricalSignals;
+    if (!signals) {
+      const missingSignalsBlock = `## Variant: ${variant.variant}
+
+**Status**: Missing empirical signals (unable to evaluate)
+`;
+      variantSections.push(missingSignalsBlock);
+      promptTelemetryByVariant[variant.variant] = {
+        factsCard: metricFromChars(0),
+        acComplianceSection: metricFromChars(0),
+        fileInventorySection: metricFromChars(0),
+        metadataSection: metricFromChars(0),
+        deliverableExcerpt: metricFromChars(0),
+        evidenceCandidatesSection: metricFromChars(0),
+        variantBlock: metricFromText(missingSignalsBlock),
+        contentTotal: metricFromChars(0),
+        scaffoldingTotal: metricFromText(missingSignalsBlock)
+      };
+      continue;
+    }
+    const factsCard = formatEmpiricalSignals(signals, variant);
+    const fileInventory = buildFileInventory(variant, {
+      maxFileInventoryFiles: adaptiveBudgetCaps.maxFileInventoryFiles
+    });
+    const { text: deliverableExcerpt, truncation } = buildVariantDeliverableExcerptForJudge(
+      variant,
+      {
+        maxDeliverableExcerptChars: adaptiveBudgetCaps.maxDeliverableExcerptChars,
+        maxDiffExcerptChars: adaptiveBudgetCaps.maxDiffExcerptChars,
+        priorityFiles: fileTargets
+      }
+    );
+    const promptOrderMode = JUDGE_FEATURE_FLAGS.JUDGE_PROFILE;
+    const evidenceCandidateLimit = computePromptOrderEvidenceCandidateLimit(
+      adaptiveBudgetCaps.maxEvidenceCandidates,
+      promptOrderMode
+    );
+    const candidates = buildVariantEvidenceCandidatesForJudge(variant, {
+      maxEvidenceCandidates: evidenceCandidateLimit
+    });
+    evidenceTextByVariant[variant.variant] = deliverableExcerpt.replace(/\r\n/g, "\n");
+    evidenceCandidatesByVariant[variant.variant] = candidates;
+    truncationByVariant[variant.variant] = truncation;
+    const metadataLines = [];
+    const outputNote = buildTruncationNote(
+      truncation.outputFullChars,
+      truncation.outputShownChars,
+      "Output"
+    );
+    const diffNote = buildTruncationNote(
+      truncation.diffFullChars,
+      truncation.diffShownChars,
+      "Diff"
+    );
+    if (outputNote || diffNote) {
+      metadataLines.push(`**Truncation**: ${[outputNote, diffNote].filter(Boolean).join(" | ")}`);
+    }
+    const worktreePath = worktreePaths?.[variant.variant];
+    if (worktreePath) {
+      metadataLines.push(`**Worktree Path**: ${worktreePath}`);
+    }
+    const verificationProvenance = formatVerificationProvenanceForPrompt(variant, {
+      worktreePath
+    });
+    if (verificationProvenance) {
+      metadataLines.push(verificationProvenance);
+    }
+    if (variant.timedOut && variant.partialEdits) {
+      const files = variant.filesChanged ?? variant.worktreeSummary?.filesChanged ?? 0;
+      const added = variant.linesAdded ?? variant.worktreeSummary?.insertions ?? 0;
+      const removed = variant.linesRemoved ?? variant.worktreeSummary?.deletions ?? 0;
+      metadataLines.push(
+        `**Timeout Recovery**: [PARTIAL/INCOMPLETE] partial edits preserved (${files} files, +${added}/-${removed})`
+      );
+    }
+    const metadataSection = metadataLines.length > 0 ? `
+${metadataLines.join("\n")}
+` : "";
+    const fileInventorySection = fileInventory ? `
+${fileInventory}
+` : "";
+    const acComplianceSection = buildACComplianceSection(contract, variant);
+    if (acComplianceSection) {
+      hasAnyACComplianceScan = true;
+    }
+    const evidenceCandidatesSection = `<<<EVIDENCE CANDIDATES (use IDs E1..E${candidates.length} OR copy/paste the exact line)>>>
+${candidates.map((c, i) => `E${i + 1}: ${c}`).join("\n")}
+<<<END EVIDENCE CANDIDATES>>>`;
+    const variantBlock = promptOrderMode === "stable" || promptOrderMode === "shadow" || promptOrderMode === "experimental" ? `## Variant: ${variant.variant}
+
+${deliverableExcerpt}
+
+${evidenceCandidatesSection}
+
+${factsCard}
+${acComplianceSection ? `${acComplianceSection}
+` : ""}${fileInventorySection}${metadataSection}
+` : `## Variant: ${variant.variant}
+
+${factsCard}
+${acComplianceSection ? `${acComplianceSection}
+` : ""}${fileInventorySection}${metadataSection}
+${deliverableExcerpt}
+
+${evidenceCandidatesSection}
+`;
+    variantSections.push(variantBlock);
+    const contentChars = deliverableExcerpt.length + evidenceCandidatesSection.length;
+    promptTelemetryByVariant[variant.variant] = {
+      factsCard: metricFromText(factsCard),
+      acComplianceSection: metricFromText(acComplianceSection ?? ""),
+      fileInventorySection: metricFromText(fileInventorySection),
+      metadataSection: metricFromText(metadataSection),
+      deliverableExcerpt: metricFromText(deliverableExcerpt),
+      evidenceCandidatesSection: metricFromText(evidenceCandidatesSection),
+      variantBlock: metricFromText(variantBlock),
+      contentTotal: metricFromChars(contentChars),
+      scaffoldingTotal: metricFromChars(variantBlock.length - contentChars)
+    };
+  }
+  const verificationIntent = variants[0]?.empiricalSignals?.verificationIntent;
+  const verificationSummary = verificationIntent ? [
+    `**VERIFICATION EXPECTATION**: ${verificationIntent.type} (confidence: ${(verificationIntent.confidence ?? 0).toFixed(2)})`,
+    verificationIntent.evidence?.length ? `Evidence: ${verificationIntent.evidence.join(" | ")}` : null,
+    verificationIntent.overrideSource ? `Override: ${verificationIntent.overrideSource}` : null
+  ].filter(Boolean).join("\n") : "";
+  const verificationSection = verificationSummary ? `${verificationSummary}
+
+` : "";
+  const promptFlags = [
+    "**PROMPT FLAGS**:",
+    `  prefersMinimalChange: ${spec.prefersMinimalChange}`,
+    `  testsRequested: ${spec.testsRequested}`,
+    `  testExecutionRequested: ${spec.testExecutionRequested}`,
+    `  testExplicitlyRequired: ${spec.testExplicitlyRequired}`,
+    `  isTestIntent: ${spec.isTestIntent}`
+  ].join("\n");
+  const resolvedTaskTypeLabel = taskKind ?? evaluationContext.taskTypeResolution.taskType ?? "unknown";
+  const taskTypeSection = `
+**TASK TYPE**: ${resolvedTaskTypeLabel}`;
+  const rebalanceEnabled = JUDGE_FEATURE_FLAGS.TEST_SIGNAL_REBALANCE === "on";
+  const inferredCodeTask = (taskKind ? /^(implementation|bugfix|refactor|feature|test)$/i.test(taskKind) : false) || !spec.isAnalysisIntent && (spec.fileConstraint.targets.length > 0 || spec.testExecutionRequested || spec.isTestIntent || /\b(code|typescript|javascript|python|test|build|lint|refactor|implementation|function|class|module|bug|fix)\b/i.test(
+    taskPrompt
+  ));
+  const testSignalPolicyLine = !rebalanceEnabled ? "- If `testGate.testStatus = failed` with executed tests (`testGate.testsRun > 0`) and `verificationStatus (adjusted, baseline-aware)` is neither `passed` nor `baseline_clean`, correctness should reflect the test failure. If adjusted verification is `baseline_clean`, treat the raw failure as pre-existing unless the diff proves otherwise." : spec.isTestIntent ? "- If `testGate.testStatus = failed` with executed tests (`testGate.testsRun > 0`) on a test-intent task and adjusted verification is neither `passed` nor `baseline_clean`, correctness should reflect the test failure. If adjusted verification is `baseline_clean`, treat the raw failure as pre-existing unless the diff proves otherwise." : spec.testExecutionRequested || spec.testExplicitlyRequired ? "- Task requires tests (per acceptance criteria or explicit request). If variant did not produce or run tests, this is an unmet requirement \u2014 score completeness accordingly. If tests were produced but fail and adjusted verification is neither `passed` nor `baseline_clean`, correctness should reflect that failure." : null;
+  const codeTaskCorrectnessGuidance = inferredCodeTask ? `
+## Code-Task Correctness Checklist
+
+- Check for self-referential function calls without a termination condition (infinite recursion risk).
+- Check for missing/undefined references (imports, variables, functions) and type-level mismatches.
+- Check for error-handling paths that silently swallow exceptions.
+- Check for control-flow hazards (unreachable code, switch fallthrough).
+
+## Correctness Scoring Guidance
+
+${testSignalPolicyLine ? `${testSignalPolicyLine}
+` : ""}- If \`buildGate.signal = fail\` and adjusted verification is neither \`passed\` nor \`baseline_clean\`, correctness should reflect the build failure. If adjusted verification is \`baseline_clean\`, treat the raw build failure as pre-existing unless the diff proves otherwise.
+- If \`Structural Risk Signals\` includes any \`CRITICAL\` finding, correctness should reflect that critical structural risk.
+- When multiple failure signals are present, weight the most severe.
+` : "";
+  const inferredBugfixWithParsing = requiresInputSimulationCheck(variants, taskPrompt, taskKind);
+  const inputSimulationGuidance = inferredBugfixWithParsing ? `
+## Input Simulation Check (required for bugfix + parsing/validation tasks)
+
+Before scoring Correctness, you MUST trace any validation/parsing logic in each variant's diff against concrete inputs visible in this prompt (variant identifiers, file paths, test data, etc.).
+
+**Required evidence format** \u2014 for each variant where parsing/validation logic is present, report and return via \`inputSimulationChecks\`:
+1. **Input**: The concrete string or value used for tracing
+2. **Code path**: The function/expression being traced
+3. **Expected result**: What the code should produce for this input
+4. **Actual result**: What the code actually produces (trace step by step)
+5. **Verdict**: PASS or FAIL with the specific condition that passes/fails (use SKIP only when no concrete input exists)
+
+If a variant's parsing logic fails on a real input visible in this prompt, its Correctness score must reflect that failure regardless of how structurally clean the code looks.
+
+If no concrete inputs are available to trace for a parsing/validation variant, include one \`inputSimulationChecks\` item with verdict=SKIP and note "No concrete inputs available for simulation."
+` : "";
+  const inputSimulationExplainabilityRequirement = inferredBugfixWithParsing ? "\n7. **inputSimulationChecks**: Required for variants with parsing/validation changes. Provide at least one check object. Use verdict=SKIP only with an explicit note when no concrete input exists." : "";
+  const acComplianceScoringGuidance = hasContractItems && hasAnyACComplianceScan ? `
+## AC Compliance Guidance
+
+Treat the AC Compliance Scan as heuristic evidence only.
+
+First determine whether the variant actually satisfies the requirement based on the strongest available evidence.
+- If the requirement is satisfied through equivalent implementation or other direct evidence, cite that evidence and score normally.
+- Only treat an AC Compliance miss as negative delivery evidence when the requirement appears genuinely unmet.
+
+Guidance:
+- A [NOT FOUND] [MUST] result is strong heuristic evidence of incompleteness, but it is not proof by itself.
+- A [NOT FOUND] [AC] or [PARTIAL] [AC] result should generally lower Delivery unless stronger evidence shows the requirement was in fact satisfied.
+- When a requirement appears unmet, include it in \`delivery.missedRequirements\`.
+- Do not let lexical or structural proxies outweigh stronger contradictory outcome evidence.
+- Implementation-detail boundary: internal helper names, object property names, constants, internal/private data-shape choices, and naming terminology are NOT acceptance requirements unless the task text, existing public API, or existing tests name that exact contract. If two variants satisfy the same user-visible behavior with different internal field names, do not mark either one as a requirement failure solely for that naming difference.
+
+Score guidance:
+- If a MUST requirement appears genuinely unmet, Delivery should generally not exceed 60.
+- If an AC item appears genuinely unmet or only partially met, Delivery should generally not exceed 75.
+` : "";
+  const finalScoreAuthorityNote = `
+## Final Score Authority
+
+Your \`os\` (overall score) is authoritative. The reporting formula weights ${THREE_BUCKET_RUBRIC_PERCENT_TEXT}. If your \`os\` diverges from that formula, explain why in your rationale.
+`;
+  const framedTaskPrompt = frameUntrustedJudgeTaskText(taskPrompt ?? "");
+  const prompt = `You are evaluating ${variants.length} AI-generated variant(s) for the following task:
+
+**TASK**: ${framedTaskPrompt}
+${taskTypeSection}
+
+${verificationSection}${promptFlags}
+
+---
+
+# Empirical Facts for Each Variant
+
+${variantSections.join("\n---\n\n")}
+
+---
+
+# Text Evidence Requirements (REQUIRED)
+
+You MUST include short supporting evidence for each variant, grounded in the deliverables above.
+
+Evidence format (choose one):
+- **Preferred**: Use evidence IDs from the **EVIDENCE CANDIDATES** list (e.g., "E3")
+- Or: Copy/paste a short quote that is a verbatim substring from the variant's **DELIVERABLE EXCERPT**
+
+Use verbatim text from excerpts. The evaluator validates that evidence matches the provided text exactly.
+
+**CRITICAL CONSTRAINTS (checked after generation)**:
+- **supportingQuotes**: Provide EXACTLY 1-2 items per variant.
+- Quotes must be **exact substrings** from the excerpt.
+- Keep quotes short (prefer <= 200 chars).
+- Use quotes to support your biggest claim(s) for the variant.
+- If you cannot find supporting quotes for a claim, you MUST lower confidence and describe the uncertainty.
+- Missing or invalid quotes are flagged during judge validation and reduce trust in the response quality.
+
+---
+
+# Anti-Verbosity Policy (ENFORCED)
+
+- **Length is NOT quality**: A longer explanation or more code does NOT merit a higher score
+- **Evaluate substance only**: Score strictly on requirements met, correctness evidence, and code clarity
+- **Concise can be better**: A concise solution that fully meets requirements is EQUAL OR SUPERIOR to verbose output
+- **Bias self-check**: If you prefer a variant for "more detail," confirm that detail was explicitly required
+- **Score willingness**: Be equally willing to assign low scores when the evidence supports it. Do not use fixed host-side score caps.
+- **Independent evaluation**: Evaluate each variant's strengths and weaknesses independently before making comparisons between variants.
+
+---
+
+# Deterministic Signal Guidance
+
+**Consider the following when scoring/ranking variants:**
+
+1. **Deterministic Signals Are Evidence, Not Filters**:
+   - Build, lint, test, execution, and deliverable signals are factual evidence for your judgment.
+   - Do not mark variants ineligible because of deterministic gates.
+   - You may choose a variant with failing verification if, after weighing all evidence, it is still the best answer.
+   - Explain clearly when the winner has failing or missing verification evidence.
+
+2. **Quality and Correctness Are Holistic**:
+   - Use the 3-bucket rubric to determine ranking across all variants.
+   - Higher quality, better delivery, and correctness evidence should drive the final decision.
+
+3. **Cite Gate Artifacts (REQUIRED)**:
+   - When making claims about builds, tests, or prompt constraints, you MUST cite recorded artifacts:
+     - Build status: Reference \`buildGate.signal\` or \`buildGate.exitCode\`
+     - Test execution: Reference \`testGate.testStatus\`, \`testGate.testsRun\`, or \`testGate.exitCode\`
+     - Execution success: Reference \`execution.success\` or \`execution.failureType\`
+     - Deliverable constraints: Reference \`deliverableTargets\` / \`deliverableSatisfied\` (when present)
+   - Example: "Build passed (buildGate.signal: healthy, exitCode: 0)"
+   - Example: "Tests failed (testGate.testStatus: failed, exitCode: 1, failed: 2)"
+
+4. **Deliverable Compliance**: When deliverable targets are specified (see
+   \`deliverableTargets\` in empirical signals), treat missing or partial deliverables
+   as evidence. Do not apply fixed delivery caps; judge the comparative quality and explain the impact.
+
+5. **Insufficient Implementation**: Treat planning-only, tests-only, missing-change, and timed-out partial outputs as evidence. Do not apply fixed caps or automatic zero scores; assign the score your judgment supports and explain the tradeoff.
+
+6. **Winner Authority**:
+   - You decide whether there is a winner.
+   - If every variant has problems, still choose the best one unless you determine no variant should win.
+
+7. **AC Compliance Guidance**:
+   - First determine whether the requirement is actually satisfied based on the strongest available evidence.
+   - If satisfied through equivalent implementation or direct evidence, cite that evidence and score normally.
+   - A [NOT FOUND] [MUST] result is strong heuristic evidence of incompleteness; if the requirement appears genuinely unmet, Delivery should generally not exceed 60.
+   - A [NOT FOUND] [AC] or [PARTIAL] [AC] result should generally lower Delivery unless stronger evidence shows the requirement was in fact satisfied.
+   - When a requirement appears unmet, include it in \`delivery.missedRequirements\`.
+${JUDGE_FEATURE_FLAGS.VARIANT_DIFFERENTIATION_SIGNALS === "on" ? `
+8. **Score Differentiation (REQUIRED)**:
+   - When variants have different diffs or different empirical signals, you MUST either:
+     (a) Cite a concrete differentiator in at least one bucket and reflect it in scoring, OR
+     (b) Provide an equivalence justification: state what specific evidence you examined,
+         confirm the differences are irrelevant to all three buckets, and explain why
+         in \`singleBiggestReason\`.
+   - Identical scores for non-identical implementations without explicit equivalence
+     justification are treated as insufficient analysis.
+` : ""}
+---
+
+# Evaluation Instructions
+
+Evaluate each variant using the **3-bucket rubric** (Delivery 50%, Correctness 30%, Quality 20%).
+${worktreePaths && Object.keys(worktreePaths).length > 0 ? `
+## File Access
+
+You have read-only access to each variant's worktree via the paths listed above.
+Use Read, Glob, and Grep tools when truncation metadata shows significant evidence
+was hidden (e.g., less than 50% visible). Start with the provided excerpts; deep-dive
+into the worktree only when the excerpts are insufficient to score confidently.
+Do NOT modify any files.
+` : ""}
+## Bucket Definitions (adapt based on task type)
+
+### For implementation/bugfix/refactor tasks:
+- **Delivery (50%)**: Did the work - requirements met, completion
+- **Correctness (30%)**: Likely correct behavior - edge cases, test signals, risk assessment
+- **Quality (20%)**: Readability, maintainability, code cleanliness
+
+### For analysis/design/planning tasks:
+- **Delivery (50%)**: Scope coverage and completeness of response
+- **Correctness (30%)**: Reasoning consistency, factual grounding
+- **Quality (20%)**: Clarity, structure, actionability
+
+${codeTaskCorrectnessGuidance}
+${inputSimulationGuidance}
+${acComplianceScoringGuidance}
+
+## Proxy vs Outcome Evidence
+
+Distinguish between proxy evidence and outcome evidence.
+
+- Proxy evidence includes naming alignment, documentation updates, structural resemblance to the requested change, keyword matches, and configuration patterns that look directionally correct.
+- Outcome evidence includes direct proof that the requested result was achieved: successful behavior, required targets actually satisfied, failing condition eliminated, or explicit verification evidence.
+
+Outcome evidence is stronger than proxy evidence.
+
+Important:
+- Multiple corroborating proxies can still be jointly wrong when none directly measures the requested outcome.
+- Do not treat documentation quality, naming alignment, or requirement-word overlap as proof that the task outcome was achieved.
+- When proxy evidence suggests completion but outcome evidence is missing or contradictory, discount the proxies and score accordingly.
+- When two variants achieve the same outcome, proxy evidence such as clarity and documentation may still differentiate quality and delivery.
+- Internal implementation details are not task requirements unless explicitly named by the task, existing public API, or existing tests. Do not turn one variant's private field names, constants, helper names, or internal/private data-shape choices into requirements for other variants.
+- 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.
+
+${finalScoreAuthorityNote}
+## Scoring Guidelines
+
+**Delivery Scoring**:
+- 90-100: All requirements met, task fully completed
+- 70-89: Most requirements met, good completion
+- 50-69: Partial requirements met, some gaps
+- 30-49: Minimal delivery, many gaps
+- 0-29: Execution failed or no meaningful output
+
+**Correctness Scoring**:
+- 90-100: High confidence in correctness, strong test coverage (testQualityLevel: proves_cli)
+- 70-89: Good correctness signals, adequate tests (testQualityLevel: validates_logic)
+- 50-69: Some correctness concerns, weak test signals
+- 30-49: Significant correctness risks
+- 0-29: Major correctness failures or execution errors
+
+**Quality Scoring**:
+- 90-100: Excellent code quality, clear patterns
+- 70-89: Good quality, minor issues
+- 50-69: Acceptable quality, some maintainability concerns
+- 30-49: Quality issues detected (magic numbers, mutations, poor structure)
+- 0-29: Poor quality
+
+**Evaluation context notes**:
+- **Change size neutrality**: Judge by requirements met and correctness evidence, not change volume. Fewer lines or more lines are irrelevant unless the prompt explicitly requests minimal/surgical change or the task clearly implies a tiny correction (e.g., a single comment/doc/typo fix). In those cases, unnecessary extra scope or new files/APIs should lower Delivery.
+- **For analysis/design/planning tasks**: Evaluate scope and reasoning quality; code changes are not expected.
+- **Timed-out partials**: If \`execution.timedOut = true\` and \`execution.partialEdits = true\`, evaluate the marked \`[PARTIAL/INCOMPLETE]\` diff and award partial credit based on delivered scope. Do not auto-score Delivery as zero solely because of timeout.
+- **Tests neutrality**: If the prompt does not request tests (testsRequested/testExecutionRequested/isTestIntent are all false), treat test additions as neutral \u2014 neither reward nor penalize.
+- **Test alignment edits**: Do not assume changed test expectations are masking failures. For test stabilization or source/test contract repair, stale expectations should be updated when current source behavior, provider registry defaults, or verified failure output supports the change. Penalize test edits as masking only when stronger source or outcome evidence contradicts the new expectation.
+- **Test quality score (0-15)** is only relevant when tests are part of the task (testsRequested or isTestIntent).
+- **Test execution results** are only relevant when running tests is part of the task (testExecutionRequested or isTestIntent).
+- **Tests vs task quality**: If tests are requested as a deliverable (testsRequested/isTestIntent), check whether test files were actually changed. Prioritize correctness of the primary task first, and use test pass/fail as a tie-breaker when candidates are truly close.
+- **Top risk severity hints**: breaking changes \u2192 major, mutations \u2192 minor (unless clearly dangerous).
+
+## Score Calibration
+
+Apply to each bucket independently:
+  90-100: Flawless execution \u2014 no defects, no missed scope, production-ready.
+  70-89:  Solid implementation \u2014 achieves the goal with 1-2 minor gaps.
+  50-69:  Partial success \u2014 core intent addressed but meaningful gaps remain.
+  30-49:  Significant problems \u2014 introduces new issues or misses major requirements.
+  0-29:   Fundamentally broken or did not attempt the task.
+Use the full range. A variant scoring 50 in one bucket can score 90 in another.
+
+## Confidence Calibration
+
+Use these anchors when determining your confidence score:
+- **95-100**: Unambiguous winner; nearly any evaluator would agree
+- **85-94**: Strong structural evidence (e.g., one variant produced deliverables while the other did not, one variant is clearly off-task, one variant's core feature is non-functional or has critical defects while the other works, or one variant omits required targets); minor residual uncertainty
+- **70-84**: Clear lean toward winner; evidence supports the ranking but some dimensions are close
+- **50-69**: Meaningful uncertainty; winner is plausible but alternative ranking is defensible
+- **40-49**: Close call; multiple plausible winners with thin evidence separation
+- **<40**: Insufficient evidence to determine a clear winner
+
+Confidence MUST reflect actual evidence quality, not just score separation. However, when structural evidence is decisive (deliverables produced vs none, on-task vs off-task, passing tests vs failing, core feature functional vs non-functional, required targets covered vs omitted), confidence should be at least 85 even if individual evidence excerpts are thin.
+
+## Score Spread Guidance
+
+- When variants have different implementations, their weighted totals SHOULD differ by at least 3 points. If within a 3-point window, provide equivalence justification in summary.rankingRationale.
+- Use the full 0-100 range per bucket. Build failures \u2192 correctness below 50. All requirements met with clean build \u2192 delivery above 80.
+- If all scores cluster within a 10-point window across all buckets, flag in summary.rankingRationale.
+
+## Explainability Requirements (ENFORCED)
+
+For each variant, you MUST provide:
+1. **deliveredWell**: 1-3 items OR ["No notable deliverables"]
+2. **correctnessStrengths**: 1-3 items OR ["No correctness strengths identified"]
+3. **qualityHighlights**: 1-2 items (required if quality.score > 70)
+4. **qualityIssues**: 1-2 items (required if quality.score < 85)
+5. **missedRequirements**: may be empty ONLY if delivery.score >= 95
+
+**Polarity rule**: deliveredWell, correctnessStrengths, and qualityHighlights must contain ONLY positive observations. Do not append caveats, limitations, or negative findings to entries in these fields. Route defects and risks to missedRequirements, topRisk, or qualityIssues respectively.
+6. **singleBiggestReason**: MUST be a structured evidence-bound object with three fields:
+   - **field**: Must reference an empiricalSignals field (changedFiles, diffStats, execution, testMetrics, codePatterns, buildGate, testGate, etc.)
+   - **value**: The actual observed value from empiricalSignals (e.g., 'none', 3, or object)
+   - **implication**: Clear explanation of what this evidence means for the score
+   - **Gate artifact citation**: When referencing gates, cite specific artifacts like exitCode, signal, stdout/stderr snippets
+${inputSimulationExplainabilityRequirement}
+
+When providing \`summary.rankingRationale\`, keep it concise (under 600 characters). Focus on the single most decisive factor and cite at least one evidence ID (E1, E2...) or file path from the evidence candidates. Detailed analysis belongs in per-variant \`singleBiggestReason\` fields.
+
+**REQUIRED**: For multi-variant evaluations, compute \`os\` (overallScore) per variant as: ${THREE_BUCKET_RUBRIC_FORMULA_TEXT}. Include \`summary.ranking\` with all variant IDs ordered by \`os\` descending. \`summary.ranking[0]\` is the winner unless you explicitly return \`"winner": null\`; that null declares that no variant should win while preserving the comparative ranking. Missing \`os\` or \`ranking\` causes schema failure.
+
+---
+
+# Output Format
+
+Return ONLY valid JSON. No markdown code fences, no prose, no explanatory text.
+
+Field rules: every "score" and "os" is an integer 0-100; "confidence.value" is a number
+between 0.0 and 1.0; \`a|b|c\` in a string value means pick exactly one of those values.
+The example below is valid, parseable JSON \u2014 emit the same shape with your own values.
+
+Example:
+
+{
+  "taskType": "implementation",
+  "variants": [
+    {
+      "variant": "variant-name",
+      "delivery": {
+        "score": 78,
+        "missedRequirements": ["requirement 1", "requirement 2"],
+        "deliveredWell": ["positive 1", "positive 2", "positive 3"]
+      },
+      "correctness": {
+        "score": 72,
+        "topRisk": {
+          "summary": "brief risk description",
+          "severity": "minor",
+          "details": "optional detailed explanation"
+        },
+        "correctnessStrengths": ["strength 1", "strength 2", "strength 3"]
+      },
+      "quality": {
+        "score": 69,
+        "qualityHighlights": ["highlight 1", "highlight 2"],
+        "qualityIssues": ["issue 1", "issue 2"],
+        "offTargetEdits": {
+          "changedFilesNotInTargets": ["file1.ts", "file2.ts"],
+          "note": "optional justification"
+        }
+      },
+      "singleBiggestReason": {
+        "field": "execution.success",
+        "value": true,
+        "implication": "Execution completed successfully with evidence-backed deliverables"
+      },
+      "confidence": {
+        "value": 0.75,
+        "reason": [
+          "evidence supporting confidence level",
+          "factors creating uncertainty (if any)"
+        ]
+      },
+      "inputSimulationChecks": [
+        {
+          "input": "cursor:auto:innovative:local",
+          "codePath": "isCanonicalVariantKey()",
+          "expectedResult": "true (valid canonical key)",
+          "actualResult": "false when parts.length === 4 check rejects model containing ':'",
+          "verdict": "FAIL",
+          "note": "Use verdict=SKIP with note only when no concrete input is available."
+        }
+      ],
+      "supportingQuotes": ["E1", "E2"],
+      "os": 79
+    }
+  ],
+  "summary": {
+    "ranking": ["variant-best", "variant-worst"],
+    "rankingRationale": "concrete reason citing empiricalSignals",
+    "confidence": 0.82,
+    "confidenceRationale": ["strong evidence from tests/build signals", "minor uncertainty remains"],
+    "top2SeparationRationale": "why top score beat runner-up"
+  }
+}
+
+**CRITICAL**: Return ONLY the JSON object above (with your values filled in). No markdown fences, no explanatory text.
+Set \`"winner": null\` only when no variant should win. Otherwise omit it and summary.ranking[0] wins.
+`;
+  const variantBlocksText = variantSections.join("\n---\n\n");
+  const diffContentChars = Object.values(promptTelemetryByVariant).reduce(
+    (sum, telemetry) => sum + telemetry.deliverableExcerpt.chars,
+    0
+  );
+  const evidenceCandidatesChars = Object.values(promptTelemetryByVariant).reduce(
+    (sum, telemetry) => sum + telemetry.evidenceCandidatesSection.chars,
+    0
+  );
+  const variantBlocksChars = variantBlocksText.length;
+  const totalChars = prompt.length;
+  const taskAndInstructionsChars = Math.max(0, totalChars - variantBlocksChars);
+  const scaffoldingChars = Math.max(0, totalChars - diffContentChars - evidenceCandidatesChars);
+  const promptTelemetry = {
+    estimator: "chars_div_4",
+    path: "3-bucket",
+    variants: promptTelemetryByVariant,
+    sections: {
+      taskAndInstructions: metricFromChars(taskAndInstructionsChars),
+      variantBlocks: metricFromChars(variantBlocksChars),
+      diffContent: metricFromChars(diffContentChars),
+      evidenceCandidates: metricFromChars(evidenceCandidatesChars),
+      scaffoldingTotal: metricFromChars(scaffoldingChars),
+      totalPrompt: metricFromChars(totalChars)
+    }
+  };
+  return {
+    prompt,
+    evidenceTextByVariant,
+    evidenceCandidatesByVariant,
+    truncationByVariant,
+    promptTelemetry,
+    evaluationContext
+  };
+}
+
+// src/core/judge/anonymization.ts
+import { createHash } from "crypto";
+var SeededRandom = class {
+  constructor(seed) {
+    this.seed = seed;
+  }
+  seed;
+  counter = 0;
+  /**
+   * Generate next random value between 0 and 1
+   */
+  next() {
+    const hash = createHash("sha256");
+    hash.update(`${this.seed}-${this.counter}`);
+    this.counter++;
+    const hex = hash.digest("hex");
+    const value = parseInt(hex.substring(0, 8), 16);
+    return value / 4294967295;
+  }
+};
+function createAnonymizationSeed(taskId, runId) {
+  const seedInput = runId ? `${taskId}:${runId}` : taskId;
+  return createHash("sha256").update(seedInput).digest("hex").slice(0, 16);
+}
+function createFallbackAnonymizationSeed(prompt, runId) {
+  const seedInput = runId ? `prompt:${prompt}:${runId}` : `prompt:${prompt}`;
+  return createHash("sha256").update(seedInput).digest("hex").slice(0, 16);
+}
+function seededShuffle(array, seed) {
+  const result = [...array];
+  const rng = new SeededRandom(seed);
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(rng.next() * (i + 1));
+    const tmp = result[i];
+    result[i] = result[j];
+    result[j] = tmp;
+  }
+  return result;
+}
+function generateAnonymousLabel(index) {
+  if (index < 26) {
+    return `Solution ${String.fromCharCode(65 + index)}`;
+  }
+  return `Solution ${index + 1}`;
+}
+function anonymizeVariants(variants, taskId, runId) {
+  if (variants.length === 0) {
+    return {
+      shuffledVariants: [],
+      originalToShuffled: /* @__PURE__ */ new Map(),
+      shuffledToOriginal: /* @__PURE__ */ new Map(),
+      variantToLabel: /* @__PURE__ */ new Map(),
+      labelToVariant: /* @__PURE__ */ new Map(),
+      seed: createAnonymizationSeed(taskId, runId)
+    };
+  }
+  const seed = createAnonymizationSeed(taskId, runId);
+  const indices = variants.map((_, i) => i);
+  const shuffledIndices = seededShuffle(indices, seed);
+  const shuffledVariants = shuffledIndices.map((originalIndex) => variants[originalIndex]);
+  const originalToShuffled = /* @__PURE__ */ new Map();
+  const shuffledToOriginal = /* @__PURE__ */ new Map();
+  const variantToLabel = /* @__PURE__ */ new Map();
+  const labelToVariant = /* @__PURE__ */ new Map();
+  for (let shuffledIndex = 0; shuffledIndex < shuffledIndices.length; shuffledIndex++) {
+    const originalIndex = shuffledIndices[shuffledIndex];
+    originalToShuffled.set(originalIndex, shuffledIndex);
+    shuffledToOriginal.set(shuffledIndex, originalIndex);
+    const variant = variants[originalIndex];
+    const label = generateAnonymousLabel(shuffledIndex);
+    if (variantToLabel.has(variant.variant)) {
+      throw new Error(
+        `Anonymization identity collision: duplicate variant key "${variant.variant}". Variant identifiers must be unique before anonymization; a collision would cause label\u2194variant misattribution during de-anonymization.`
+      );
+    }
+    variantToLabel.set(variant.variant, label);
+    labelToVariant.set(label, variant.variant);
+  }
+  return {
+    shuffledVariants,
+    originalToShuffled,
+    shuffledToOriginal,
+    variantToLabel,
+    labelToVariant,
+    seed
+  };
+}
+function restoreOriginalOrder(evaluations, mapping) {
+  if (evaluations.length > 0 && evaluations.length !== mapping.size) {
+    throw new Error(
+      `restoreOriginalOrder: evaluation count mismatch \u2014 ${evaluations.length} evaluation(s) returned for ${mapping.size} variant(s). The judge returned a partial evaluation set; restoring would drop or duplicate a variant silently.`
+    );
+  }
+  const restored = new Array(evaluations.length);
+  for (let shuffledIndex = 0; shuffledIndex < evaluations.length; shuffledIndex++) {
+    const originalIndex = mapping.get(shuffledIndex);
+    if (originalIndex === void 0) {
+      throw new Error(
+        `restoreOriginalOrder: no original-index mapping for shuffled index ${shuffledIndex}. The shuffled\u2192original mapping is incomplete relative to the evaluations being restored.`
+      );
+    }
+    if (originalIndex >= evaluations.length) {
+      throw new Error(
+        `restoreOriginalOrder: evaluation count mismatch \u2014 shuffled index ${shuffledIndex} maps to original index ${originalIndex}, which is out of bounds for ${evaluations.length} evaluation(s). The judge returned fewer evaluations than variants; a variant would be dropped silently.`
+      );
+    }
+    restored[originalIndex] = evaluations[shuffledIndex];
+  }
+  return restored;
+}
+function resolveAnonymizationRunId(options) {
+  const runIdFromOptions = options.runId;
+  if (typeof runIdFromOptions === "string" && runIdFromOptions.trim().length > 0) {
+    return runIdFromOptions.trim();
+  }
+  const labRunId = readEnv(POETIC_LAB_RUN_ID).value;
+  if (typeof labRunId === "string" && labRunId.trim().length > 0) {
+    return labRunId.trim();
+  }
+  return void 0;
+}
+function shouldAnonymize(options) {
+  if (options?.anonymizeJudge === false) return false;
+  if (options?.noAnonymizeJudge === true) return false;
+  return true;
+}
+function createAnonymizedVariantCopies(variants, variantToLabel) {
+  return variants.map((variant) => {
+    const label = variantToLabel.get(variant.variant);
+    if (!label) return variant;
+    return { ...variant, variant: label };
+  });
+}
+function deAnonymizeRationale(text, idMapping, labelMapping) {
+  let result = text;
+  const allMappings = [
+    ...Object.entries(idMapping),
+    ...labelMapping ? Object.entries(labelMapping) : []
+  ];
+  allMappings.sort((a, b) => b[0].length - a[0].length);
+  for (const [anonymous, real] of allMappings) {
+    const escaped = anonymous.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    result = result.replace(new RegExp(`\\b${escaped}\\b`, "g"), real);
+  }
+  return result;
+}
+
+// src/core/judge/duplicate-detector.ts
+var IMPORT_PATTERN = /^(?:import\b|export\s+(?:\*|\{[^}]*\})\s+from\b|const\s+[\w$]+\s*=\s*require\s*\(|require\s*\()/i;
+var LICENSE_HEADER_PATTERN = /^(?:\/\/|\/\*|\*|#)\s*(?:copyright|license|licensed under|spdx[- ]license[- ]identifier)/i;
+var TEST_SCAFFOLD_PATTERN = /^(?:describe|it|test|beforeEach|afterEach|beforeAll|afterAll)\s*\(/i;
+var TEST_HARNESS_PATTERN = /^(?:vi|jest)\.(?:mock|clearAllMocks|resetAllMocks|restoreAllMocks|useFakeTimers|useRealTimers)\s*\(/i;
+var STRUCTURAL_LINE_PATTERN = /^[()[\]{};,\s]+$/;
+var MIN_SUBSTANTIVE_LINES_FLOOR = 3;
+var MIN_SUBSTANTIVE_LINE_RATIO = 0.4;
+function fnv1aHash(str) {
+  const FNV_OFFSET_BASIS = 2166136261;
+  const FNV_PRIME = 16777619;
+  let hash = FNV_OFFSET_BASIS;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, FNV_PRIME);
+  }
+  return hash >>> 0;
+}
+function normalizeLine(line) {
+  const trimmed = line.trimEnd();
+  const leadingMatch = trimmed.match(/^[\s]+/);
+  if (!leadingMatch) return trimmed;
+  const leadingSpaces = leadingMatch[0].replace(/\t/g, "  ");
+  return leadingSpaces + trimmed.trimStart();
+}
+function isBoilerplateLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return true;
+  if (IMPORT_PATTERN.test(trimmed)) return true;
+  if (LICENSE_HEADER_PATTERN.test(trimmed)) return true;
+  if (TEST_SCAFFOLD_PATTERN.test(trimmed)) return true;
+  if (TEST_HARNESS_PATTERN.test(trimmed)) return true;
+  if (STRUCTURAL_LINE_PATTERN.test(trimmed)) return true;
+  return false;
+}
+function detectDuplicateContent(content, options = {}) {
+  const minBlockLines = options.minBlockLines ?? 10;
+  const threshold = options.threshold ?? 0.1;
+  const minSubstantiveLines = Math.max(
+    MIN_SUBSTANTIVE_LINES_FLOOR,
+    Math.ceil(minBlockLines * MIN_SUBSTANTIVE_LINE_RATIO)
+  );
+  const lines = content.split("\n");
+  if (lines.length < minBlockLines) {
+    return {
+      hasDuplicates: false,
+      duplicationRatio: 0,
+      duplicateBlockCount: 0,
+      totalLines: lines.length,
+      duplicatedLines: 0
+    };
+  }
+  const normalizedLines = lines.map(normalizeLine);
+  const blockMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i <= normalizedLines.length - minBlockLines; i++) {
+    const blockLines = normalizedLines.slice(i, i + minBlockLines);
+    const substantiveLineCount = blockLines.reduce(
+      (count, line) => count + (isBoilerplateLine(line) ? 0 : 1),
+      0
+    );
+    if (substantiveLineCount < minSubstantiveLines) {
+      continue;
+    }
+    const blockContent = blockLines.join("\n");
+    const hash = fnv1aHash(blockContent);
+    if (!blockMap.has(hash)) {
+      blockMap.set(hash, []);
+    }
+    blockMap.get(hash)?.push({ startLine: i, block: blockContent });
+  }
+  const duplicatePairs = [];
+  for (const entries of blockMap.values()) {
+    if (entries.length < 2) continue;
+    const contentGroups = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      if (!contentGroups.has(entry.block)) {
+        contentGroups.set(entry.block, []);
+      }
+      contentGroups.get(entry.block)?.push(entry.startLine);
+    }
+    for (const [, positions] of contentGroups) {
+      if (positions.length < 2) continue;
+      const sortedPositions = [...positions].sort((a, b) => a - b);
+      for (let i = 0; i < sortedPositions.length - 1; i++) {
+        for (let j = i + 1; j < sortedPositions.length; j++) {
+          const leftStart = sortedPositions[i];
+          const rightStart = sortedPositions[j];
+          if (rightStart < leftStart + minBlockLines) {
+            continue;
+          }
+          let matchLength = minBlockLines;
+          while (leftStart + matchLength < normalizedLines.length && rightStart + matchLength < normalizedLines.length && normalizedLines[leftStart + matchLength] === normalizedLines[rightStart + matchLength]) {
+            matchLength++;
+          }
+          duplicatePairs.push({
+            left: {
+              startLine: leftStart,
+              endLine: leftStart + matchLength - 1
+            },
+            right: {
+              startLine: rightStart,
+              endLine: rightStart + matchLength - 1
+            }
+          });
+        }
+      }
+    }
+  }
+  duplicatePairs.sort((a, b) => {
+    const aLength = a.left.endLine - a.left.startLine;
+    const bLength = b.left.endLine - b.left.startLine;
+    return bLength - aLength;
+  });
+  const selectedPairs = [];
+  for (const pair of duplicatePairs) {
+    const covered = selectedPairs.some(
+      (selected) => pair.left.startLine >= selected.left.startLine && pair.left.endLine <= selected.left.endLine && pair.right.startLine >= selected.right.startLine && pair.right.endLine <= selected.right.endLine
+    );
+    if (!covered) {
+      selectedPairs.push(pair);
+    }
+  }
+  const duplicatedLineSet = /* @__PURE__ */ new Set();
+  for (const pair of selectedPairs) {
+    for (let line = pair.left.startLine; line <= pair.left.endLine; line++) {
+      duplicatedLineSet.add(line);
+    }
+    for (let line = pair.right.startLine; line <= pair.right.endLine; line++) {
+      duplicatedLineSet.add(line);
+    }
+  }
+  const duplicatedLines = duplicatedLineSet.size;
+  const totalLines = lines.length;
+  const duplicationRatio = totalLines > 0 ? duplicatedLines / totalLines : 0;
+  const duplicateBlockCount = selectedPairs.length;
+  return {
+    hasDuplicates: duplicationRatio >= threshold,
+    duplicationRatio,
+    duplicateBlockCount,
+    totalLines,
+    duplicatedLines
+  };
+}
+
+// src/core/judge/judge-failure-artifacts.ts
+import { mkdirSync, writeFileSync } from "fs";
+import path2 from "path";
+var DEFAULT_ARTIFACT_BASE_DIR = path2.join(".poetic", "artifacts");
+function safeLabPathComponent(value) {
+  const trimmed = value?.trim();
+  return trimmed && /^[A-Za-z0-9_-]+$/.test(trimmed) ? trimmed : void 0;
+}
+function defaultArtifactBaseDir() {
+  const poeticDir = path2.join(process.cwd(), ".poetic");
+  if (readEnv(POETIC_LAB_MODE).value !== true) {
+    return path2.join(process.cwd(), DEFAULT_ARTIFACT_BASE_DIR);
+  }
+  const labId = safeLabPathComponent(readEnv(POETIC_LAB_ID).value);
+  const runId = safeLabPathComponent(readEnv(POETIC_LAB_RUN_ID).value);
+  if (!labId || !runId) {
+    return path2.join(process.cwd(), DEFAULT_ARTIFACT_BASE_DIR);
+  }
+  return path2.join(poeticDir, "labs", labId, "runs", runId, "artifacts");
+}
+function persistJudgeFailureArtifact(args) {
+  try {
+    const safeTaskId = (args.taskId || "unknown").replace(/[^A-Za-z0-9._-]/g, "_");
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const artifactBase = args.artifactBaseDir ?? defaultArtifactBaseDir();
+    const dir = path2.join(artifactBase, safeTaskId);
+    mkdirSync(dir, { recursive: true });
+    const filename = `judge-failure-${args.label}-${timestamp}.txt`;
+    writeFileSync(path2.join(dir, filename), sanitizeString(args.response), "utf-8");
+  } catch {
+  }
+}
+
+// src/core/judge/judge-model-normalizer.ts
+function resolveClaudeModelRole(role, fallbackRole) {
+  try {
+    return ProviderRegistry.getModelForRole("claude", role) ?? (fallbackRole ? ProviderRegistry.getModelForRole("claude", fallbackRole) : void 0) ?? ProviderRegistry.getDefaultModel("claude") ?? "sonnet";
+  } catch {
+    switch (role) {
+      case "quality":
+        return "opus";
+      case "fast":
+        return "haiku";
+      default:
+        return fallbackRole ?? "sonnet";
+    }
+  }
+}
+var CLAUDE_SONNET_DATED = resolveClaudeModelRole("judge_primary");
+var CLAUDE_OPUS_DATED = resolveClaudeModelRole("quality");
+var CLAUDE_HAIKU_DATED = resolveClaudeModelRole("fast");
+function getDefaultJudgeModel() {
+  return resolveClaudeModelRole("judge_primary");
+}
+function getDefaultMultiLensJudgeModel() {
+  return resolveClaudeModelRole("quality");
+}
+function normalizeJudgeModel(model, env = process.env) {
+  const envJudgeModel = env.POETIC_JUDGE_MODEL?.trim();
+  const envJudgeProvider = env.POETIC_JUDGE_PROVIDER?.trim();
+  const resolved = resolveJudgeConfig(
+    {
+      judgeModel: model?.trim() || envJudgeModel,
+      judgeProvider: envJudgeProvider
+    },
+    process.cwd()
+  );
+  const resolvedModel = String(resolved.model.value ?? "").trim();
+  if (resolvedModel.length > 0 && resolvedModel !== "auto") {
+    return {
+      model: resolvedModel,
+      provider: resolved.provider.value,
+      warnings: []
+    };
+  }
+  return { model: getDefaultJudgeModel(), provider: resolved.provider.value, warnings: [] };
+}
+
+// src/core/judge/variant-result-coherence.ts
+import { existsSync } from "fs";
+function checkVariantResultCoherence(variantId, options) {
+  const issues = [];
+  let checksPerformed = 0;
+  let checksPassed = 0;
+  checksPerformed++;
+  const parsed = parseVariantIdentifier(variantId || "");
+  if (!parsed.provider) {
+    issues.push({
+      check: "variant_id_not_canonical",
+      detail: `Variant ID "${variantId}" is not canonical (expected provider:model:strategy:mode format)`,
+      severity: "warning"
+    });
+  } else {
+    checksPassed++;
+  }
+  if (options?.checkWorktreePath && options.retainedWorktreePath) {
+    checksPerformed++;
+    if (existsSync(options.retainedWorktreePath)) {
+      checksPassed++;
+    } else {
+      issues.push({
+        check: "worktree_path_missing",
+        detail: `Retained worktree path "${options.retainedWorktreePath}" does not exist on disk`,
+        severity: "warning"
+      });
+    }
+  }
+  return {
+    coherent: issues.length === 0,
+    issues,
+    checksPerformed,
+    checksPassed
+  };
+}
+
+// src/core/judge/pre-score-gate-context.ts
+var SKIPPED_VERIFICATION_COVERAGE = /* @__PURE__ */ new Set([
+  "skipped_not_relevant",
+  "skipped_no_command",
+  "skipped_tool_unavailable"
+]);
+function isSkippedVerificationCoverage(status) {
+  return status !== void 0 && (SKIPPED_VERIFICATION_COVERAGE.has(status) || status === "not_run");
+}
+function shouldSuppressUnverifiedFullTestScope(tg) {
+  if (tg.scope !== "full") return false;
+  const filesTested = Array.isArray(tg.filesTested) ? tg.filesTested.filter((file) => typeof file === "string" && file.trim().length > 0) : [];
+  if (filesTested.length > 0) return false;
+  const command = typeof tg.command === "string" ? tg.command.trim() : "";
+  if (!command) return false;
+  return describeVerificationCommand(command).scope !== "full";
+}
+function resolveBuildGatePromptSignal(gate, gateSource) {
+  if (gateSource === "unavailable" || gateSource === "execution_provenance") {
+    return "unavailable";
+  }
+  const status = gate.verificationCoverage?.build.status ?? gate.buildGate.verificationCoverage?.status;
+  if (isSkippedVerificationCoverage(status)) return "skipped";
+  return gate.buildGate.signal;
+}
+function resolveLintGatePromptStatus(gate, gateSource) {
+  if (gateSource === "unavailable" || gateSource === "execution_provenance") {
+    return "unavailable";
+  }
+  const lintCoverageStatus = gate.verificationCoverage?.lint.status ?? gate.lintGate?.verificationCoverage?.status;
+  if (isSkippedVerificationCoverage(lintCoverageStatus)) return "skipped";
+  if (lintCoverageStatus === "unverified") return "unknown";
+  if (gate.lintGate) return gate.lintGate.passed ? "pass" : "fail";
+  return "not_run";
+}
+function resolveTestGatePromptSource(testGate, gateSource) {
+  if (testGate?.evidenceSource === "reused_provenance") {
+    return "execution_provenance";
+  }
+  return gateSource;
+}
+function isLexicalRequirementCoverageOnly(gateResults) {
+  const { requirementGate } = gateResults;
+  const details = Array.isArray(requirementGate.details) ? requirementGate.details : [];
+  if (requirementGate.totalCount === 0 || details.length === 0 || details.length !== requirementGate.totalCount) {
+    return false;
+  }
+  return details.every((detail) => detail.verificationDepth === "lexical");
+}
+function normalizeUnmeasuredLiveTestGate(gateResults) {
+  const testGate = gateResults.testGate;
+  if (testGate?.testStatus !== "passed" || testGate.metricsAvailable !== false) {
+    return gateResults;
+  }
+  return {
+    ...gateResults,
+    testGate: {
+      ...testGate,
+      testStatus: "not_run",
+      availability: "unavailable",
+      skipReason: "no-supported-test-runner",
+      testsRun: 0,
+      testsPassed: 0,
+      testsFailed: 0,
+      exitCode: void 0
+    },
+    ...gateResults.verificationCoverage ? {
+      verificationCoverage: {
+        ...gateResults.verificationCoverage,
+        test: {
+          status: "skipped_no_command",
+          command: testGate.command,
+          reason: "Verification unavailable: the test command emitted no measurable test results."
+        }
+      }
+    } : {}
+  };
+}
+function renderRequirementGateSummary(gateResults, gateSource) {
+  const source = gateSource === "live_gate" ? " [source=live_gate]" : "";
+  const { requirementGate } = gateResults;
+  const count = `(${requirementGate.satisfiedCount}/${requirementGate.totalCount})`;
+  if (requirementGate.totalCount === 0) {
+    return [
+      `requirementGate: not_evaluated ${count}${source} [reason=no_requirements_parsed_from_prompt]`
+    ];
+  }
+  if (isLexicalRequirementCoverageOnly(gateResults)) {
+    const status = requirementGate.satisfied ? "satisfied" : "partial";
+    const lines = [
+      `requirementGate: heuristic-${status} ${count}${source} [depth=lexical, heuristic=true]`
+    ];
+    if (!requirementGate.satisfied) {
+      lines.push(
+        "requirementCoverageHeuristicNote: lexical keyword misses are not definitive acceptance failures; for behavioral requirements, prefer executed outcome evidence and directly named public API/test contracts."
+      );
+    }
+    return lines;
+  }
+  return [
+    `requirementGate: ${requirementGate.satisfied ? "satisfied" : "failed"} ${count}${source}`
+  ];
+}
+async function computeDeterministicPreScoreGateContext(variants, taskPrompt, options, loggerTag = "Judge", taskTypeResolution) {
+  const gateResultsByVariant = /* @__PURE__ */ new Map();
+  const structuralRisksByVariant = /* @__PURE__ */ new Map();
+  const gateSourceByVariant = /* @__PURE__ */ new Map();
+  const spec = options.evaluationContext?.promptSpec ?? parsePromptSpec(taskPrompt);
+  const taskTypeBlocksCodeSignals = taskTypeResolution !== void 0 && (!taskTypeSignalsEnabled(taskTypeResolution) || taskTypeResolution.taskType !== "code");
+  const likelyTechnical = !spec.isAnalysisIntent && (spec.fileConstraint.targets.length > 0 || spec.isTestIntent || spec.testExecutionRequested || /\b(code|typescript|javascript|python|test|build|lint|refactor|implement|implementation|function|class|module|bug|fix|endpoint|schema|migration)\b/i.test(
+    taskPrompt
+  ));
+  if (!likelyTechnical || variants.length === 0 || taskTypeBlocksCodeSignals) {
+    return {
+      gateResultsByVariant,
+      structuralRisksByVariant,
+      gateSourceByVariant,
+      isCodeTask: false
+    };
+  }
+  const requirements = spec.isAnalysisIntent ? [] : spec.requirements;
+  const shouldRunBuildGate = requirements.length > 0 && variants.length > 1;
+  const repoPath = options.repoPath || process.cwd();
+  const baselineTypecheck = shouldRunBuildGate ? await (await import("./build-gate-YFASRB5Z.js")).collectBaselineTypecheck(repoPath) : null;
+  const baselineHealthy = baselineTypecheck?.ok ?? false;
+  const hasExecutionTestProvenance = variants.some(
+    (variant) => hasTestExecutionProvenance(variant)
+  );
+  const shouldRunTestGate = Boolean(
+    hasExecutionTestProvenance || spec.isTestIntent || spec.testExecutionRequested
+  );
+  const testGateMode = spec.testExecutionRequested ? "full" : "affected";
+  const enrichedVariantsByName = /* @__PURE__ */ new Map();
+  await Promise.all(
+    variants.map(async (variant) => {
+      const diffText = extractDiffText(variant);
+      const changedFiles = extractChangedFilesMeta(diffText).map((meta) => meta.path);
+      structuralRisksByVariant.set(variant.variant, scanDiffForStructuralRisks(diffText));
+      const variantPath = options.variantPaths?.[variant.variant] || variant.retainedWorktreePath || null;
+      try {
+        let gateResults;
+        let gateSource;
+        if (!variantPath) {
+          gateSource = hasTestExecutionProvenance(variant) ? "execution_provenance" : "unavailable";
+          gateResults = buildDegradedGateResults(variant, baselineHealthy, gateSource);
+        } else {
+          gateSource = "live_gate";
+          gateResults = normalizeUnmeasuredLiveTestGate(
+            await runPreScoreGates(variantPath, changedFiles, requirements, baselineHealthy, {
+              runBuildGate: shouldRunBuildGate,
+              runLintGate: options.competitionMode === true && changedFiles.some((file) => categorizeFile(file) === "source"),
+              variant,
+              runTestGate: shouldRunTestGate,
+              testGateMode,
+              abortSignal: options.abortSignal,
+              baselineTypecheck: baselineTypecheck ? {
+                errorKeys: baselineTypecheck.errorKeys,
+                typecheckExecutable: baselineTypecheck.typecheckExecutable
+              } : void 0
+            })
+          );
+        }
+        gateResultsByVariant.set(variant.variant, gateResults);
+        gateSourceByVariant.set(variant.variant, gateSource);
+        const telemetryTaskId = options.taskId?.trim();
+        if (telemetryTaskId) {
+          options.telemetry?.logValidationResult?.({
+            taskId: telemetryTaskId,
+            variantId: variant.variant,
+            gateResults
+          });
+        }
+        const variantCopy = {
+          ...variant,
+          empiricalSignals: variant.empiricalSignals ? { ...variant.empiricalSignals } : void 0
+        };
+        applyLiveTestGateProvenance(variantCopy, gateResults.testGate);
+        if (variantCopy.empiricalSignals && gateResults.buildGate) {
+          variantCopy.empiricalSignals.buildGate = {
+            signal: gateResults.buildGate.signal,
+            typeErrorCount: gateResults.buildGate.typeErrorCount,
+            fatalErrorCount: gateResults.buildGate.fatalErrorCount,
+            baselineHealthy: gateResults.buildGate.baselineHealthy,
+            newErrorCount: gateResults.buildGate.newErrorCount,
+            baselineComparisonAvailable: gateResults.buildGate.baselineComparisonAvailable,
+            compilerCountsAvailable: gateResults.buildGate.compilerCountsAvailable
+          };
+        }
+        if (variantCopy.empiricalSignals && gateResults.testGate) {
+          variantCopy.empiricalSignals.testGate = {
+            testStatus: gateResults.testGate.testStatus,
+            testsRun: gateResults.testGate.testsRun,
+            testsFailed: gateResults.testGate.testsFailed,
+            testsPassed: gateResults.testGate.testsPassed,
+            exitCode: gateResults.testGate.exitCode,
+            signalConsistency: gateResults.testGate.signalConsistency
+          };
+        }
+        {
+          const findings = [];
+          if (gateResults.buildGate.signal === "fail") {
+            findings.push({
+              kind: "build",
+              command: gateResults.buildGate.command ?? "build",
+              exitCode: 1,
+              outputTail: gateResults.buildGate.stderrTail || gateResults.buildGate.outputTail,
+              severity: "error"
+            });
+          }
+          if (gateResults.testGate?.availability === "executed" && (gateResults.testGate.testStatus === "failed" || gateResults.testGate.testStatus === "error")) {
+            findings.push({
+              kind: "test",
+              command: "test",
+              exitCode: gateResults.testGate.exitCode ?? 1,
+              outputTail: gateResults.testGate.outputTail,
+              severity: "error"
+            });
+          }
+          if (findings.length > 0) {
+            const existing = variantCopy.verification?.findings ?? [];
+            const merged = [...existing, ...findings];
+            variantCopy.verification = {
+              passed: !merged.some((finding) => finding.severity === "error"),
+              findings: merged
+            };
+          }
+        }
+        if (variantCopy.empiricalSignals && JUDGE_FEATURE_FLAGS.VARIANT_DIFFERENTIATION_SIGNALS !== "off") {
+          const coherence = checkVariantResultCoherence(variantCopy.variant, {
+            retainedWorktreePath: variantCopy.retainedWorktreePath
+          });
+          variantCopy.empiricalSignals.coherenceCheck = {
+            coherent: coherence.coherent,
+            issues: coherence.issues.map((issue) => ({
+              check: issue.check,
+              detail: issue.detail
+            }))
+          };
+        }
+        enrichedVariantsByName.set(variantCopy.variant, variantCopy);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(
+          `[${loggerTag}] Pre-score gate evaluation failed for ${variant.variant}: ${message}`
+        );
+        gateResultsByVariant.delete(variant.variant);
+        gateSourceByVariant.delete(variant.variant);
+      }
+    })
+  );
+  return {
+    gateResultsByVariant,
+    structuralRisksByVariant,
+    gateSourceByVariant,
+    isCodeTask: true,
+    enrichedVariants: variants.map(
+      (variant) => enrichedVariantsByName.get(variant.variant) ?? variant
+    )
+  };
+}
+function applyLiveTestGateProvenance(variant, testGate) {
+  if (!testGate || testGate.testStatus === "not_run") return;
+  const hasExistingExecutedTests = Boolean(
+    variant.testsExecuted && variant.testsExecuted.scope !== "none"
+  );
+  const liveGateFailed = testGate.testStatus === "failed" || testGate.testStatus === "error" || testGate.testStatus === "timeout";
+  const existingFailed = variant.testStatus === "failed" || variant.testStatus === "error" || variant.testStatus === "timeout";
+  const liveGatePassed = testGate.testStatus === "passed";
+  if (hasExistingExecutedTests && (variant.testStatus === "passed" && liveGateFailed || existingFailed && liveGatePassed)) {
+    return;
+  }
+  variant.testStatus = testGate.testStatus;
+  variant.testMetrics = {
+    totalTests: testGate.testsRun,
+    passedTests: testGate.testsPassed,
+    failedTests: testGate.testsFailed,
+    durationMs: testGate.duration,
+    passRate: testGate.testsRun > 0 ? testGate.testsPassed / testGate.testsRun * 100 : void 0
+  };
+  variant.testsExecuted = {
+    scope: testGate.scope,
+    filesTested: testGate.filesTested,
+    command: testGate.command,
+    ...testGate.commands && testGate.commands.length > 0 ? { commands: testGate.commands } : {},
+    exitCode: testGate.exitCode,
+    durationMs: testGate.duration,
+    ...testGate.failingTests && testGate.failingTests.length > 0 ? { failingTests: testGate.failingTests } : {},
+    ...testGate.outputTail ? { outputTail: testGate.outputTail } : {}
+  };
+}
+function buildDegradedGateResults(variant, baselineHealthy, gateSource) {
+  let testGate;
+  const testsExecuted = variant.testsExecuted;
+  let buildPassed = false;
+  if (gateSource === "execution_provenance" && testsExecuted && testsExecuted.scope !== "none") {
+    const scope = testsExecuted.scope === "targeted" ? "touched" : testsExecuted.scope;
+    const exitCode = testsExecuted.exitCode;
+    const isEnvCommandFailure = (code) => code === 126 || code === 127;
+    const recordedStatus = normalizeRecordedTestStatus(variant.testStatus);
+    const recordedFailure = recordedStatus === "failed" || recordedStatus === "error" || recordedStatus === "timeout";
+    const inferredStatus = recordedStatus === "not_run" ? "not_run" : (
+      // Fail closed against a clean recorded exit code in two ways, matching the
+      // ordering the live reuse path in test-gate.ts already uses (a recorded
+      // status wins; the exit code only fills a gap):
+      //  - a recorded FAILURE is not masked by `exitCode: 0`;
+      //  - a status outside the interpretable vocabulary is not resolved to
+      //    `passed` by `exitCode: 0` either. Failure inference from a non-zero
+      //    exit stays unchanged.
+      recordedFailure ? recordedStatus : hasUnrecognizedRecordedTestStatus(variant.testStatus) && exitCode === 0 ? "not_run" : exitCode === 0 ? "passed" : exitCode === 124 ? "timeout" : isEnvCommandFailure(exitCode) ? "error" : exitCode === void 0 ? recordedStatus ?? "not_run" : "failed"
+    );
+    const failedTests = variant.testMetrics?.failedTests ?? 0;
+    const totalTests = variant.testMetrics?.totalTests ?? 0;
+    const hasExecutionEvidence = hasRecordedTestExecutionEvidence({
+      command: testsExecuted.command,
+      filesTested: testsExecuted.filesTested,
+      totalTests,
+      exitCode: testsExecuted.exitCode
+    });
+    const normalizedStatus = hasExecutionEvidence && !(inferredStatus === "passed" && totalTests === 0) ? inferredStatus : "not_run";
+    const isContradiction = inferredStatus === "failed" && failedTests === 0 && totalTests > 0;
+    testGate = {
+      testStatus: normalizedStatus,
+      availability: normalizedStatus === "not_run" ? "unavailable" : "executed",
+      skipReason: normalizedStatus === "not_run" ? "no-execution-provenance" : void 0,
+      testsRun: normalizedStatus === "not_run" ? 0 : totalTests,
+      testsPassed: normalizedStatus === "not_run" ? 0 : variant.testMetrics?.passedTests ?? 0,
+      testsFailed: normalizedStatus === "not_run" ? 0 : failedTests,
+      // A recorded count is the only measurement evidence available on the
+      // degraded (no-worktree) path; without it the zeros above are "unknown",
+      // not "zero tests ran".
+      ...normalizedStatus === "not_run" ? { metricsAvailable: false } : { metricsAvailable: true },
+      duration: testsExecuted.durationMs ?? variant.testMetrics?.durationMs ?? 0,
+      filesTested: normalizedStatus === "not_run" ? [] : testsExecuted.filesTested ?? [],
+      command: normalizedStatus === "not_run" ? "" : testsExecuted.command ?? "",
+      scope: normalizedStatus === "not_run" ? "none" : scope,
+      exitCode: normalizedStatus === "not_run" ? void 0 : exitCode,
+      outputTail: testsExecuted.outputTail,
+      failingTests: testsExecuted.failingTests ?? [],
+      signalConsistency: isContradiction ? "inconsistent" : "consistent"
+    };
+    buildPassed = normalizedStatus === "passed";
+  }
+  const buildGate = {
+    signal: "unknown",
+    errors: [],
+    baselineComparisonAvailable: false,
+    baselineHealthy,
+    fatalErrorCount: 0,
+    typeErrorCount: 0,
+    warningCount: 0,
+    verificationCoverage: {
+      status: "skipped_no_command",
+      reason: "Variant worktree unavailable."
+    }
+  };
+  return {
+    // Requirement validation needs the variant worktree. Keep the typed
+    // compatibility shape neutral; gateSource carries the unavailable state.
+    requirementGate: {
+      satisfied: true,
+      satisfiedCount: 0,
+      totalCount: 0,
+      missingRequirements: [],
+      details: []
+    },
+    buildGate,
+    lintGate: void 0,
+    testGate,
+    verificationCoverage: {
+      build: {
+        status: "skipped_no_command",
+        reason: "Variant worktree unavailable."
+      },
+      lint: {
+        status: "skipped_no_command",
+        reason: "Variant worktree unavailable."
+      }
+    },
+    buildPassed,
+    lintPassed: false,
+    isEligible: true
+  };
+}
+function clipSnippet2(text, maxChars = 500) {
+  if (typeof text !== "string") return null;
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return null;
+  if (trimmed.length <= maxChars) return trimmed;
+  return `${trimmed.slice(0, maxChars)}...`;
+}
+function buildDeterministicPreScoreGateSection(gateResults, structuralRisks, options) {
+  if (!gateResults && !structuralRisks) return void 0;
+  const gateSource = options?.gateSource;
+  const noVariantPath = gateSource === "execution_provenance" || gateSource === "unavailable";
+  const lines = [];
+  if (gateResults) {
+    if (noVariantPath) {
+      lines.push("requirementGate: unavailable [source=unavailable, reason=no_variant_path]");
+    } else {
+      lines.push(...renderRequirementGateSummary(gateResults, gateSource));
+    }
+    if (gateSource === "live_gate") {
+      const buildSignal = resolveBuildGatePromptSignal(gateResults, gateSource);
+      const buildSkipped = buildSignal === "skipped";
+      const compilerCountsMeasured = gateResults.buildGate.compilerCountsAvailable !== false;
+      const buildDetails = !options?.includeCompilerCounts ? "" : compilerCountsMeasured ? ` (typeErrorCount: ${gateResults.buildGate.typeErrorCount}, fatalErrorCount: ${gateResults.buildGate.fatalErrorCount}${typeof gateResults.buildGate.newErrorCount === "number" ? `, newErrorCount: ${gateResults.buildGate.newErrorCount}` : ""})` : " (compilerCounts: unavailable, non-Node build output not parsed)";
+      lines.push(`buildGate: ${buildSignal}${buildSkipped ? "" : buildDetails} [source=live_gate]`);
+    } else {
+      lines.push("buildGate: unavailable [source=unavailable, reason=no_variant_path]");
+    }
+    const tg = gateResults.testGate;
+    const testSource = resolveTestGatePromptSource(tg, gateSource);
+    if (!tg && gateSource === "unavailable") {
+      lines.push("testGate: unavailable [source=unavailable, reason=no_verified_test_provenance]");
+    } else {
+      const suppressFullScope = tg ? shouldSuppressUnverifiedFullTestScope(tg) : false;
+      const renderedScope = tg?.scope && tg.scope !== "none" && !suppressFullScope ? `, scope=${tg.scope}` : "";
+      const renderedSource = testSource ? ` [source=${testSource}${renderedScope}]` : tg?.scope && tg.scope !== "none" && !suppressFullScope ? ` [scope=${tg.scope}]` : "";
+      const command = typeof tg?.command === "string" && tg.command.trim().length > 0 ? escapeEvidenceForJudgePromptDisplay(tg.command.trim()) : void 0;
+      const commandDetail = suppressFullScope && command ? `, command: ${command}` : "";
+      lines.push(
+        `testGate: ${tg?.testStatus ?? "not_run"}${tg ? ` (testsRun: ${tg.testsRun}, testsFailed: ${tg.testsFailed}, testsPassed: ${tg.testsPassed}${tg.exitCode !== void 0 ? `, exitCode: ${tg.exitCode}` : ""}${tg.metricsAvailable === false ? ", metricsAvailable: false" : ""}${commandDetail})${renderedSource}` : renderedSource}`
+      );
+      if (suppressFullScope && command) {
+        lines.push(
+          `WARNING: recorded test scope was "full" but the executed command is not classified as a full suite and selectedFiles were empty. Do not treat this as evidence that the variant's new tests ran.`
+        );
+      }
+    }
+    if (tg?.testStatus === "passed" && tg.metricsAvailable === false) {
+      lines.push(
+        'WARNING: the test command exited 0 but emitted no parseable test counts, so testsRun/testsPassed above are "unknown", not measured zeros. This is not evidence that tests executed; do not cite it as verified test coverage.'
+      );
+    }
+    if (tg?.signalConsistency === "inconsistent") {
+      lines.push(
+        "WARNING: exitCode indicates failure but parser found 0 failing tests. Likely infrastructure/tooling error, not a clean test pass. Do not interpret parsed metrics as evidence of passing tests."
+      );
+    }
+    const lintStatus = resolveLintGatePromptStatus(gateResults, gateSource);
+    if (gateSource === "live_gate") {
+      lines.push(`lintGate: ${lintStatus} [source=live_gate]`);
+    } else {
+      lines.push("lintGate: unavailable [source=unavailable, reason=no_variant_path]");
+    }
+    if (lintStatus === "fail") {
+      lines.push(
+        "(Lint primarily enforces style/formatting rules. Not a functional correctness signal unless a specific rule flags a defect.)"
+      );
+    }
+    lines.push(`gateEligibilityObservation: ${gateResults.isEligible} [telemetry_only]`);
+    if (gateResults.diagnosticReason) {
+      lines.push(
+        `gateEligibilityReasonObservation: ${gateResults.diagnosticReason} [telemetry_only]`
+      );
+    }
+  }
+  if (options?.isCodeTask) {
+    if (structuralRisks) {
+      if (structuralRisks.applicability === "not_applicable") {
+        lines.push(
+          "structuralRisks: not_applicable (heuristic targets JS/TS syntax; unsupported-language absence is not checked-clean) [source=heuristic, method=diff-pattern-matching, no AST]"
+        );
+      } else if (structuralRisks.applicability === "unknown" && structuralRisks.findings.length === 0) {
+        lines.push(
+          "structuralRisks: unknown (no classifiable source paths for structural-risk heuristics) [source=heuristic, method=diff-pattern-matching, no AST]"
+        );
+      } else {
+        const applicabilityNote = structuralRisks.applicability === "mixed" ? " applicability=mixed (only JS/TS paths scanned)" : "";
+        lines.push(
+          `structuralRisks: critical=${structuralRisks.criticalCount}, major=${structuralRisks.majorCount}, minor=${structuralRisks.minorCount}${applicabilityNote} [source=heuristic, method=diff-pattern-matching, no AST. Corroborate with build/test before weighing this signal. False positives expected on large refactors.]`
+        );
+        if (structuralRisks.findings.length > 0) {
+          lines.push("Structural Risk Signals:");
+          for (const finding of structuralRisks.findings.slice(0, 3)) {
+            const displayPath = finding.filePath !== void 0 ? escapePathForJudgePromptDisplay(finding.filePath) : void 0;
+            const location = displayPath && finding.line ? `${displayPath}:${finding.line}` : displayPath ?? "unknown location";
+            lines.push(
+              `  - ${finding.severity.toUpperCase()}: ${finding.summary} (${location}) [heuristic: diff-only brace-counting, no AST]`
+            );
+            if (finding.evidence) {
+              lines.push(
+                `    evidence: ${escapeEvidenceForJudgePromptDisplay(finding.evidence.slice(0, 200))}`
+              );
+            }
+          }
+        }
+      }
+    }
+    const testFailureSnippet = clipSnippet2(gateResults?.testGate?.outputTail, 500);
+    if (gateResults && (testFailureSnippet || (gateResults.testGate?.failingTests?.length ?? 0) > 0) && (gateResults.testGate?.testStatus === "failed" || gateResults.testGate?.testStatus === "timeout" || gateResults.testGate?.testStatus === "error")) {
+      const failingTests = gateResults.testGate?.failingTests;
+      if (failingTests && failingTests.length > 0) {
+        const maxFailedTestNames = 5;
+        const failedTestPreview = failingTests.slice(0, maxFailedTestNames).map(escapeEvidenceForJudgePromptDisplay);
+        const remainingFailedTests = failingTests.length - failedTestPreview.length;
+        const suffix = remainingFailedTests > 0 ? ` (+${remainingFailedTests} more)` : "";
+        lines.push(`failedTestNames: ${failedTestPreview.join(", ")}${suffix}`);
+      }
+      if (testFailureSnippet) {
+        lines.push("testFailureDetails:");
+        lines.push(
+          ...testFailureSnippet.split("\n").map((line) => `  ${escapeEvidenceForJudgePromptDisplay(line)}`)
+        );
+      }
+      lines.push(
+        "redResultClassification: required \u2014 classify this result as production_defect, stale_fixture, intentional_contract_change, or infrastructure_failure, citing the supplied failure evidence."
+      );
+    }
+    if (gateResults) {
+      const buildFailureSnippet = clipSnippet2(
+        gateResults.buildGate.stderrTail || gateResults.buildGate.outputTail || gateResults.buildGate.stdoutTail,
+        500
+      );
+      if (buildFailureSnippet && gateResults.buildGate.signal === "fail") {
+        lines.push("buildFailureDetails:");
+        lines.push(
+          ...buildFailureSnippet.split("\n").map((line) => `  ${escapeEvidenceForJudgePromptDisplay(line)}`)
+        );
+      }
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/core/judge/ranking-validation.ts
+function normalizeRankingIds(rawRanking, variantsList) {
+  const exactVariants = new Set(variantsList.map((variant) => variant.variant));
+  return rawRanking.map((entry) => {
+    const trimmed = entry.trim();
+    if (exactVariants.has(trimmed)) return trimmed;
+    const idMatch = trimmed.match(/^v(\d+)$/i);
+    if (!idMatch) return trimmed;
+    const idx = Number(idMatch[1]) - 1;
+    if (!Number.isFinite(idx) || idx < 0 || idx >= variantsList.length) {
+      return trimmed;
+    }
+    return variantsList[idx]?.variant ?? trimmed;
+  });
+}
+function validateRanking(ranking, knownVariants, variantsList) {
+  if (!Array.isArray(ranking)) {
+    return { valid: false, reason: "ranking_not_array" };
+  }
+  if (ranking.length === 0) {
+    return { valid: false, reason: "ranking_empty" };
+  }
+  if (!ranking.every((entry) => typeof entry === "string" && entry.trim().length > 0)) {
+    return { valid: false, reason: "ranking_non_string" };
+  }
+  const raw = ranking.map((entry) => String(entry).trim());
+  const normalized = variantsList ? normalizeRankingIds(raw, variantsList) : raw;
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of normalized) {
+    if (entry.trim().length === 0) {
+      return { valid: false, reason: "ranking_non_string" };
+    }
+    if (seen.has(entry)) {
+      return { valid: false, reason: "ranking_duplicate_variant" };
+    }
+    seen.add(entry);
+    if (!knownVariants.has(entry)) {
+      return { valid: false, reason: "ranking_unknown_variant" };
+    }
+  }
+  if (normalized.length > knownVariants.size) {
+    return { valid: false, reason: "ranking_length_mismatch" };
+  }
+  const partial = normalized.length < knownVariants.size;
+  return { valid: true, ranking: normalized, partial };
+}
+function checkRankingScoreConsistency(ranking, scoresByVariant) {
+  for (let i = 0; i < ranking.length - 1; i++) {
+    const current = ranking[i];
+    const next = ranking[i + 1];
+    const currentScore = scoresByVariant.get(current);
+    const nextScore = scoresByVariant.get(next);
+    if (currentScore === void 0 || nextScore === void 0) continue;
+    if (nextScore > currentScore) {
+      return {
+        inconsistent: true,
+        details: `rk[${i}]="${current}" (os=${currentScore}) < rk[${i + 1}]="${next}" (os=${nextScore})`
+      };
+    }
+  }
+  return { inconsistent: false };
+}
+
+// src/core/judge/intent-utils.ts
+function isAnalysisIntent(variant) {
+  return variant.executionIntent === "analysis" || variant.executionCategory === "analysis" || variant.completenessScore?.editMode === "analysis";
+}
+
+// src/core/judge/static-planning-detection.ts
+function detectPlanningCategoryStatic(variant) {
+  const filesChanged = variant.emptyChanges ? 0 : variant.gitMetrics?.filesChanged ?? variant.filesChanged ?? variant.worktreeSummary?.filesChanged ?? 0;
+  const output = extractCleanStdout(variant);
+  const planningKeywords = [
+    "approach:",
+    "strategy:",
+    "plan:",
+    "step-by-step",
+    "step by step",
+    "implementation steps",
+    "steps:",
+    "todo",
+    "fixme",
+    "consideration:",
+    "recommendation:",
+    "1.",
+    "2.",
+    "3.",
+    "first,",
+    "second,",
+    "then,",
+    "finally,",
+    "would need to",
+    "should be",
+    "could implement"
+  ];
+  const lowerOutput = output.toLowerCase();
+  const keywordMatches = planningKeywords.filter((kw) => lowerOutput.includes(kw)).length;
+  const hasStepHeadings = /\bstep\s+\d+\b/i.test(output);
+  const bulletCount = (output.match(/^\s*[-*]\s+/gm) ?? []).length;
+  const numberedLineCount = (output.match(/^\s*\d+[).]\s+/gm) ?? []).length;
+  const numberedHeadingCount = (output.match(/^\s*#{1,6}\s*\d+[).:]\s+/gm) ?? []).length;
+  const stepHeadingCount = (output.match(/^\s*#{1,6}\s*step\s+\d+\b/gim) ?? []).length;
+  const hasStructuredList = bulletCount >= 3 || numberedLineCount >= 3 || numberedHeadingCount >= 2 || stepHeadingCount >= 2;
+  const isLikelyPlanning = filesChanged === 0 && // Keep this conservative to avoid false positives:
+  // - Require substantial output length (> 500 chars), not just a short note.
+  // - Require several planning signals (3+ keyword hits) or a clearly structured list.
+  output.length > 500 && (keywordMatches >= 3 || hasStepHeadings || hasStructuredList);
+  return isLikelyPlanning ? "planning" : "implementation";
+}
+
+// src/core/judge/output-inspection-gate.ts
+var MIN_STDOUT_LENGTH = 80;
+function inspectVariantOutput(variant, options = {}) {
+  const reasons = [];
+  const { editsExpected = true } = options;
+  const cleanStdout = extractCleanStdout(variant);
+  const filesChanged = variant.gitMetrics?.filesChanged ?? variant.filesChanged ?? 0;
+  const hasWorktreeDiff = Boolean(variant.worktreeDiff && variant.worktreeDiff.length > 0);
+  const diffText = hasWorktreeDiff ? extractDiffText(variant) : "";
+  const evidence = {
+    stdoutLength: cleanStdout.length,
+    diffLength: diffText.length,
+    filesChanged,
+    hasWorktreeDiff
+  };
+  let passed = false;
+  const stdoutOnlyPlanningForCodeTask = editsExpected && cleanStdout.length > 0 && diffText.length === 0 && filesChanged === 0 && detectPlanningCategoryStatic(variant) === "planning";
+  if (cleanStdout.length >= MIN_STDOUT_LENGTH && !stdoutOnlyPlanningForCodeTask) {
+    passed = true;
+    reasons.push(`stdout >= ${MIN_STDOUT_LENGTH} chars (${cleanStdout.length})`);
+  }
+  if (cleanStdout.length > 0 && cleanStdout.length < MIN_STDOUT_LENGTH && !stdoutOnlyPlanningForCodeTask) {
+    passed = true;
+    reasons.push(`stdout > 0 chars (${cleanStdout.length})`);
+  }
+  if (stdoutOnlyPlanningForCodeTask) {
+    reasons.push("stdout-only output classified as planning for code task");
+  }
+  if (editsExpected) {
+    if (hasWorktreeDiff && diffText.length > 0) {
+      passed = true;
+      reasons.push(`diff > 0 chars (${diffText.length})`);
+    }
+    if (filesChanged > 0) {
+      passed = true;
+      reasons.push(`filesChanged > 0 (${filesChanged})`);
+    }
+  } else {
+    if (hasWorktreeDiff && diffText.length > 0) {
+      reasons.push("diff > 0 chars (bonus, editsExpected=false)");
+    }
+    if (filesChanged > 0) {
+      reasons.push("filesChanged > 0 (bonus, editsExpected=false)");
+    }
+  }
+  if (!passed) {
+    reasons.push("No tangible output detected");
+    reasons.push(`stdout: ${cleanStdout.length} chars (min: ${MIN_STDOUT_LENGTH})`);
+    if (editsExpected) {
+      reasons.push(`diff: ${diffText.length} chars`);
+      reasons.push(`filesChanged: ${filesChanged}`);
+    } else {
+      reasons.push("(editsExpected=false: only stdout required)");
+    }
+  }
+  return {
+    passed,
+    reasons,
+    evidence
+  };
+}
+function inspectAllVariants(variants, options = {}) {
+  const results = /* @__PURE__ */ new Map();
+  const editsExpected = options?.editsExpected ?? true;
+  for (const variant of variants) {
+    const result = inspectVariantOutput(variant, options);
+    if (!editsExpected && result.evidence.stdoutLength >= MIN_STDOUT_LENGTH && result.evidence.diffLength === 0 && result.evidence.filesChanged === 0) {
+      results.set(variant.variant, {
+        ...result,
+        passed: true,
+        reasons: [`stdout >= ${MIN_STDOUT_LENGTH} chars (analysis-only task)`]
+      });
+    } else {
+      results.set(variant.variant, result);
+    }
+  }
+  return results;
+}
+
+// src/core/judge/variant-health.ts
+var STRATEGY_TOKENS = /* @__PURE__ */ new Set([
+  "conservative",
+  "innovative",
+  "hybrid",
+  "fast",
+  "fusion",
+  "balanced",
+  "default"
+]);
+var MODE_TOKENS = /* @__PURE__ */ new Set(["local", "cloud", "api", "headless"]);
+var EFFORT_TOKENS = /* @__PURE__ */ new Set(["minimal", "low", "medium", "high", "extra-high", "xhigh", "max"]);
+var EFFORT_PREFIX = "effort-";
+function resolveNoOutputGateMode() {
+  return JUDGE_FEATURE_FLAGS.NO_OUTPUT_PREEVAL_GATE;
+}
+function resolveEffectiveNoOutputGateMode(_options) {
+  const configured = resolveNoOutputGateMode();
+  return configured === "off" ? "off" : "shadow";
+}
+function normalizeTestProvenanceScope(variant) {
+  const scope = variant.testsExecuted?.scope;
+  if (!scope) return "unknown";
+  if (scope === "none") return "none";
+  if (scope === "full") return "full";
+  const command = variant.testsExecuted?.command?.toLowerCase() ?? "";
+  if (command.includes("smoke")) return "smoke";
+  return "scoped";
+}
+function parseVariantIdentity(variant) {
+  const identity = {
+    provider: variant.provider,
+    model: variant.resolvedModel ?? variant.model,
+    strategy: variant.strategy,
+    mode: variant.executionMode
+  };
+  const parts = String(variant.variant ?? "").split(":").filter(Boolean);
+  if (parts.length === 0) return identity;
+  identity.provider ??= parts[0];
+  const last = parts.at(-1);
+  if (last && MODE_TOKENS.has(last)) {
+    identity.mode ??= last;
+    parts.pop();
+  }
+  const maybeStrategy = parts.at(-1);
+  if (maybeStrategy && STRATEGY_TOKENS.has(maybeStrategy)) {
+    identity.strategy ??= maybeStrategy;
+    parts.pop();
+  }
+  const effortPairIndex = parts.findIndex(
+    (part, index) => part === "effort" && EFFORT_TOKENS.has(parts[index + 1] ?? "")
+  );
+  if (effortPairIndex >= 0) {
+    identity.effortLevel ??= parts[effortPairIndex + 1];
+    parts.splice(effortPairIndex, 2);
+  }
+  const effortIndex = parts.findIndex(
+    (part) => part.startsWith(EFFORT_PREFIX) || EFFORT_TOKENS.has(part)
+  );
+  if (effortIndex >= 0) {
+    const effortToken = parts[effortIndex];
+    identity.effortLevel ??= effortToken.startsWith(EFFORT_PREFIX) ? effortToken.slice(EFFORT_PREFIX.length) : effortToken;
+    parts.splice(effortIndex, 1);
+  }
+  if (!identity.model && parts.length >= 2) {
+    identity.model = parts.slice(1).join(":");
+  }
+  return identity;
+}
+function classifyVariantHealth(args) {
+  if (isAnalysisIntent(args.variant)) return "valid_analysis";
+  if (args.filesChanged > 0 || args.diffLength > 0) return "valid_materialized";
+  if (args.hasTestExecution) return "valid_test_only";
+  if (args.inspectionPassed) return "weak_evidence";
+  if (args.stdoutLength > 0) return "weak_evidence";
+  return "invalid_materialization";
+}
+function buildVariantHealth(input) {
+  const gateMode = input.gateMode ?? resolveNoOutputGateMode();
+  const effectiveGateMode = input.effectiveGateMode ?? gateMode;
+  const cleanStdout = extractCleanStdout(input.variant);
+  const filesChanged = input.variant.gitMetrics?.filesChanged ?? input.variant.filesChanged ?? 0;
+  const stdoutLength = input.inspection?.evidence.stdoutLength ?? cleanStdout.length;
+  const diffLength = input.inspection?.evidence.diffLength ?? (input.variant.worktreeDiff ? extractDiffText(input.variant).length : 0);
+  const hasTestExecution = input.hasTestExecution ?? (input.variant.testsExecuted?.scope ?? "none") !== "none";
+  const inspectionPassed = input.inspection?.passed ?? (stdoutLength > 0 || diffLength > 0 || filesChanged > 0);
+  const classification = classifyVariantHealth({
+    variant: input.variant,
+    filesChanged,
+    stdoutLength,
+    diffLength,
+    hasTestExecution,
+    inspectionPassed
+  });
+  const wouldExclude = input.wouldExclude ?? false;
+  const wasExcluded = false;
+  const identity = parseVariantIdentity(input.variant);
+  return {
+    taskId: input.options?.taskId,
+    judgeKind: input.judgeKind,
+    gateMode,
+    effectiveGateMode,
+    judgeStrict: input.options?.judgeStrict === true,
+    variant: input.variant.variant,
+    provider: identity.provider,
+    model: identity.model,
+    strategy: identity.strategy,
+    effortLevel: identity.effortLevel,
+    mode: identity.mode,
+    promptIntent: input.promptIntent,
+    executionIntent: input.variant.executionIntent,
+    filesChanged,
+    diffLength,
+    stdoutLength,
+    testProvenanceScope: normalizeTestProvenanceScope(input.variant),
+    classification,
+    shownToLlm: input.shownToLlm ?? !wasExcluded,
+    candidateSetImpact: {
+      wouldExclude,
+      wasExcluded,
+      counterfactualWinnerChange: "unknown"
+    }
+  };
+}
+function logVariantHealthEvents(telemetry, variantHealth) {
+  if (!telemetry?.logVariantHealth) return;
+  for (const health of variantHealth) {
+    telemetry.logVariantHealth(health);
+  }
+}
+function observeVariantHealth(args) {
+  const r5AnalysisExempt = args.explicitReviewExemptsR5 && args.isExplicitReview;
+  const noOutputGateMode = resolveNoOutputGateMode();
+  const effectiveNoOutputGateMode = resolveEffectiveNoOutputGateMode(args.options);
+  const variantHealth = args.variants.map((variant) => {
+    const inspection = args.inspectionLookup?.(variant) ?? inspectVariantOutput(variant);
+    const hasTestExecution = hasTestExecutionProvenance(variant);
+    const wouldExclude = !r5AnalysisExempt && !inspection.passed && !hasTestExecution && !isAnalysisIntent(variant);
+    return buildVariantHealth({
+      variant,
+      judgeKind: args.judgeKind,
+      promptIntent: args.isExplicitReview ? "explicit-review" : void 0,
+      options: args.options,
+      inspection,
+      hasTestExecution,
+      gateMode: noOutputGateMode,
+      effectiveGateMode: effectiveNoOutputGateMode,
+      wouldExclude,
+      wasExcluded: false,
+      shownToLlm: true
+    });
+  });
+  logVariantHealthEvents(args.telemetry, variantHealth);
+  logR5NoOutputShadowObservations({
+    gateMode: noOutputGateMode,
+    variantHealth,
+    taskId: args.taskId,
+    telemetry: args.telemetry,
+    resolveVariantId: args.resolveVariantId,
+    onWouldExclude: args.onWouldExclude
+  });
+  return variantHealth;
+}
+function logR5NoOutputShadowObservations(args) {
+  if (args.gateMode === "off") {
+    return;
+  }
+  const wouldExcludeHealth = args.variantHealth.filter(
+    (health) => health.candidateSetImpact.wouldExclude
+  );
+  if (wouldExcludeHealth.length === 0) {
+    return;
+  }
+  const resolveVariantId = args.resolveVariantId ?? ((variantId) => variantId);
+  for (const health of wouldExcludeHealth) {
+    args.onWouldExclude?.(resolveVariantId(health.variant));
+  }
+  const taskId = args.taskId?.trim();
+  if (!taskId || !args.telemetry?.logShadowDelta) {
+    return;
+  }
+  args.telemetry.logShadowDelta({
+    tier: "gate",
+    flag: "NO_OUTPUT_PREEVAL_GATE",
+    taskId,
+    applied: false,
+    wouldChangeEligibility: true,
+    affectedVariants: wouldExcludeHealth.map((health) => ({
+      variant: resolveVariantId(health.variant),
+      currentEligible: true,
+      shadowEligible: false
+    }))
+  });
+}
+
+// src/core/judge/winner-from-scores.ts
+var DEFAULT_DETERMINISTIC_WINNER_WEIGHTS = {
+  delivery: DETERMINISTIC_WINNER_WEIGHTS.delivery,
+  correctness: DETERMINISTIC_WINNER_WEIGHTS.correctness,
+  quality: DETERMINISTIC_WINNER_WEIGHTS.quality
+};
+var DEFAULT_DETERMINISTIC_WINNER_THRESHOLDS = {
+  abstainMargin: 0.5,
+  tieMargin: 2
+};
+function toFiniteNumber(value) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+function clampScore(score, outOfRange) {
+  if (score < 0 || score > 100) {
+    if (outOfRange) outOfRange.count++;
+  }
+  return Math.max(0, Math.min(100, score));
+}
+function weighted(delivery, correctness, quality, weights) {
+  return delivery * weights.delivery + correctness * weights.correctness + quality * weights.quality;
+}
+function scoreVariant(entry, weights, outOfRange) {
+  const declaredOverallScore = entry.declaredOverallScore;
+  if (typeof declaredOverallScore === "number" && Number.isFinite(declaredOverallScore) && declaredOverallScore >= 0 && declaredOverallScore <= 100) {
+    return {
+      score: declaredOverallScore,
+      source: "llm_declared_overall_score"
+    };
+  }
+  const bucketDelivery = toFiniteNumber(entry.bucketScores?.delivery);
+  const bucketCorrectness = toFiniteNumber(entry.bucketScores?.correctness);
+  const bucketQuality = toFiniteNumber(entry.bucketScores?.quality);
+  if (bucketDelivery != null && bucketCorrectness != null && bucketQuality != null) {
+    return {
+      score: clampScore(
+        weighted(bucketDelivery, bucketCorrectness, bucketQuality, weights),
+        outOfRange
+      ),
+      source: "bucket_scores"
+    };
+  }
+  const codeCorrectness = toFiniteNumber(entry.codeQuality?.correctness);
+  const codeQualitySignals = [
+    toFiniteNumber(entry.codeQuality?.readability),
+    toFiniteNumber(entry.codeQuality?.maintainability),
+    toFiniteNumber(entry.codeQuality?.innovation)
+  ].filter((value) => value != null);
+  const codeQuality = codeQualitySignals.length > 0 ? codeQualitySignals.reduce((sum, value) => sum + value, 0) / codeQualitySignals.length : null;
+  const codeCompleteness = toFiniteNumber(entry.codeQuality?.completeness);
+  if (codeCompleteness != null && codeCorrectness != null && codeQuality != null) {
+    return {
+      score: clampScore(
+        weighted(codeCompleteness, codeCorrectness, codeQuality, weights),
+        outOfRange
+      ),
+      source: "code_quality"
+    };
+  }
+  const qualityScore = toFiniteNumber(entry.qualityScore);
+  if (qualityScore != null) {
+    return { score: clampScore(qualityScore, outOfRange), source: "quality_score" };
+  }
+  return { score: 0, source: "fallback_zero" };
+}
+function normalizeThresholds(thresholds) {
+  const abstainMargin = Math.max(
+    0,
+    Number.isFinite(Number(thresholds?.abstainMargin)) ? Number(thresholds?.abstainMargin) : DEFAULT_DETERMINISTIC_WINNER_THRESHOLDS.abstainMargin
+  );
+  const tieCandidate = Math.max(
+    0,
+    Number.isFinite(Number(thresholds?.tieMargin)) ? Number(thresholds?.tieMargin) : DEFAULT_DETERMINISTIC_WINNER_THRESHOLDS.tieMargin
+  );
+  return {
+    abstainMargin,
+    tieMargin: Math.max(tieCandidate, abstainMargin)
+  };
+}
+function selectDeterministicWinnerFromScores(entries, options) {
+  if (!entries || entries.length === 0) {
+    return {
+      winner: null,
+      reason: "no_variants",
+      margin: null,
+      top2: [],
+      scored: [],
+      thresholds: normalizeThresholds(options?.thresholds),
+      outOfRangeCount: 0
+    };
+  }
+  const weights = {
+    delivery: Number.isFinite(Number(options?.weights?.delivery)) ? Number(options?.weights?.delivery) : DEFAULT_DETERMINISTIC_WINNER_WEIGHTS.delivery,
+    correctness: Number.isFinite(Number(options?.weights?.correctness)) ? Number(options?.weights?.correctness) : DEFAULT_DETERMINISTIC_WINNER_WEIGHTS.correctness,
+    quality: Number.isFinite(Number(options?.weights?.quality)) ? Number(options?.weights?.quality) : DEFAULT_DETERMINISTIC_WINNER_WEIGHTS.quality
+  };
+  const thresholds = normalizeThresholds(options?.thresholds);
+  const outOfRange = { count: 0 };
+  const scored = entries.map((entry) => {
+    const scoredVariant = scoreVariant(entry, weights, outOfRange);
+    return {
+      variant: entry.variant,
+      compositeScore: createPercentScore(
+        scoredVariant.score,
+        `deterministic score ${entry.variant}`
+      ),
+      scoreSource: scoredVariant.source
+    };
+  });
+  scored.sort((a, b) => {
+    const scoreDelta = Number(b.compositeScore) - Number(a.compositeScore);
+    if (scoreDelta !== 0) return scoreDelta;
+    return a.variant.localeCompare(b.variant);
+  });
+  const eligibleScored = scored;
+  const leader = eligibleScored[0];
+  const runnerUp = eligibleScored[1];
+  const margin = leader && runnerUp ? Number(leader.compositeScore) - Number(runnerUp.compositeScore) : null;
+  const top2 = eligibleScored.slice(0, 2).map((item) => ({
+    variant: item.variant,
+    score: Number(item.compositeScore)
+  }));
+  if (!leader) {
+    return {
+      winner: null,
+      reason: "no_variants",
+      margin,
+      top2,
+      scored,
+      thresholds,
+      outOfRangeCount: outOfRange.count
+    };
+  }
+  const isTiebreak = runnerUp != null && margin === 0;
+  return {
+    winner: leader.variant,
+    reason: "winner_by_score",
+    margin,
+    top2,
+    scored,
+    thresholds,
+    outOfRangeCount: outOfRange.count,
+    ...isTiebreak ? { tiebreakReason: "lexical_name_order" } : {}
+  };
+}
+function computeSelfConsistencyWarning(winnerId, deterministicWinner) {
+  if (deterministicWinner.scored.length === 0) return void 0;
+  const topScorer = deterministicWinner.scored[0];
+  const winnerScored = deterministicWinner.scored.find((s) => s.variant === winnerId);
+  if (topScorer && winnerScored && topScorer.variant !== winnerId && Number(topScorer.compositeScore) - Number(winnerScored.compositeScore) > 10) {
+    return `Ranking winner "${winnerId}" composite=${Number(winnerScored.compositeScore).toFixed(1)} is >10pts below top scorer "${topScorer.variant}" composite=${Number(topScorer.compositeScore).toFixed(1)}`;
+  }
+  return void 0;
+}
+
+export {
+  isCodeIntent,
+  runPreScoreGates,
+  createPercentScore,
+  percentScoreToNumber,
+  scanDiffForStructuralRisks,
+  evaluateACComplianceItems,
+  buildACComplianceSection,
+  requiresInputSimulationCheck,
+  computePromptOrderEvidenceCandidateLimit,
+  computeAdaptiveJudgePromptBudgetCaps,
+  buildVariantEvidenceCandidatesForJudge,
+  evidenceQuoteIsValid,
+  buildVariantDeliverableExcerptForJudge,
+  resolveAcceptanceCriteriaTargets,
+  buildAIPrompt3Bucket,
+  SeededRandom,
+  createFallbackAnonymizationSeed,
+  anonymizeVariants,
+  restoreOriginalOrder,
+  resolveAnonymizationRunId,
+  shouldAnonymize,
+  createAnonymizedVariantCopies,
+  deAnonymizeRationale,
+  detectDuplicateContent,
+  persistJudgeFailureArtifact,
+  getDefaultJudgeModel,
+  getDefaultMultiLensJudgeModel,
+  normalizeJudgeModel,
+  resolveBuildGatePromptSignal,
+  resolveLintGatePromptStatus,
+  resolveTestGatePromptSource,
+  computeDeterministicPreScoreGateContext,
+  buildDeterministicPreScoreGateSection,
+  normalizeRankingIds,
+  validateRanking,
+  checkRankingScoreConsistency,
+  inspectVariantOutput,
+  inspectAllVariants,
+  observeVariantHealth,
+  selectDeterministicWinnerFromScores,
+  computeSelfConsistencyWarning
+};
+//# sourceMappingURL=chunk-TSPQONRT.js.map