@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-3OPP2OZB.js

@@ -0,0 +1,1480 @@
+import {
+  isUnavailableVerificationFinding,
+  parseVerificationErrorsForChannel
+} from "./chunk-PXKERBKX.js";
+import {
+  channelsFailingIdenticallyOnBase,
+  parseFailureOutput
+} from "./chunk-AHU3FKPA.js";
+import {
+  IssueSet,
+  UNPARSEABLE_BUILD_SENTINEL,
+  UNPARSEABLE_LINT_SENTINEL,
+  UNPARSEABLE_TEST_SENTINEL,
+  compareVerificationStates,
+  detectEmptyRun,
+  extractStableVerificationState,
+  parseGenericPassFailOutput
+} from "./chunk-TUQMMFEQ.js";
+import {
+  describeVerificationCommand,
+  detectZeroCollectedTests,
+  wrapperReportsInnerMissingLaunch
+} from "./chunk-EPAMVGI3.js";
+import {
+  isTelemetryDebug
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/verification/comparison-identity.ts
+var CHANNEL_SENTINEL = {
+  build: UNPARSEABLE_BUILD_SENTINEL,
+  lint: UNPARSEABLE_LINT_SENTINEL,
+  test: UNPARSEABLE_TEST_SENTINEL
+};
+function isUnparseableSentinel(code, channel) {
+  const sentinel = CHANNEL_SENTINEL[channel];
+  return code === sentinel || code.startsWith(`${sentinel}:`);
+}
+function setHasUnparseableSentinel(issues, channel) {
+  return issues.toArray().some((issue) => isUnparseableSentinel(issue.code, channel));
+}
+function channelIdentityUnavailable(delta, channel) {
+  return setHasUnparseableSentinel(delta.persistingIssues, channel) || delta.regradedImprovements !== void 0 && setHasUnparseableSentinel(delta.regradedImprovements, channel);
+}
+function storedComparisonUnavailableChannels(comparison) {
+  if (comparison.summary.comparisonUnavailable !== true) return [];
+  if (comparison.summary.comparisonUnavailableChannels) {
+    return [...comparison.summary.comparisonUnavailableChannels];
+  }
+  const dimensions = [
+    ["build", comparison.types],
+    ["lint", comparison.lint],
+    ["test", comparison.tests]
+  ];
+  return dimensions.filter(
+    ([channel, dimension]) => [...dimension?.persistingIssues ?? [], ...dimension?.fixedIssues ?? []].some(
+      (label) => label.includes(CHANNEL_SENTINEL[channel])
+    )
+  ).map(([channel]) => channel);
+}
+function assessComparisonIdentityAvailability(delta, contexts = {}) {
+  const channels = [];
+  for (const channel of ["build", "lint", "test"]) {
+    if (contexts[channel]?.skip === true) continue;
+    if (channelIdentityUnavailable(delta[channel], channel)) {
+      channels.push(channel);
+    }
+  }
+  if (channels.length === 0) {
+    return { unavailable: false, channels };
+  }
+  const detail = channels.map((channel) => `${channel} (language '${contexts[channel]?.language ?? "unknown"}')`).join(", ");
+  return {
+    unavailable: true,
+    channels,
+    reason: `Issue identity could not be established for: ${detail}. Both sides failed with output no structured parser recognised, so the comparison proves neither a regression nor its absence.`
+  };
+}
+
+// src/core/verification/types.ts
+function isVerificationAccepted(status) {
+  return status === "passed" || status === "baseline_clean";
+}
+var VERIFICATION_OUTCOME_CONTRACT_VERSION = 1;
+function outcomeStatus(status, exitCode) {
+  return status ?? (exitCode === 0 ? "passed" : "failed");
+}
+function outcomeLanguage(language) {
+  return language ?? "unknown";
+}
+function verificationOutcomesFromGateArtifacts(gates, options = {}) {
+  const testTotals = gates.tests ? comparableTestTotals(gates.tests) : void 0;
+  const build = {
+    channel: "build",
+    status: outcomeStatus(gates.build.status, gates.build.exitCode),
+    exitCode: gates.build.exitCode,
+    outputTail: gates.build.outputTail,
+    language: outcomeLanguage(gates.build.language),
+    parserVersion: VERIFICATION_OUTCOME_CONTRACT_VERSION,
+    command: gates.build.command,
+    commandProvenance: {
+      command: gates.build.command,
+      cwd: options.cwd,
+      source: options.source ?? "deterministic-gate"
+    },
+    stdoutTail: gates.build.stdoutTail,
+    stderrTail: gates.build.stderrTail,
+    verificationCoverage: gates.build.verificationCoverage,
+    commandResults: gates.build.commandResults
+  };
+  return {
+    build,
+    lint: gates.lint ? {
+      channel: "lint",
+      status: outcomeStatus(gates.lint.status, gates.lint.exitCode),
+      exitCode: gates.lint.exitCode,
+      outputTail: gates.lint.outputTail,
+      language: outcomeLanguage(gates.lint.language),
+      parserVersion: VERIFICATION_OUTCOME_CONTRACT_VERSION,
+      command: gates.lint.command,
+      commandProvenance: {
+        command: gates.lint.command,
+        cwd: options.cwd,
+        source: options.source ?? "deterministic-gate"
+      },
+      verificationCoverage: gates.lint.verificationCoverage,
+      commandResults: gates.lint.commandResults
+    } : void 0,
+    tests: gates.tests ? {
+      channel: "test",
+      status: outcomeStatus(gates.tests.status, gates.tests.exitCode),
+      exitCode: gates.tests.exitCode,
+      outputTail: gates.tests.outputTail,
+      language: outcomeLanguage(gates.tests.language),
+      parserVersion: VERIFICATION_OUTCOME_CONTRACT_VERSION,
+      command: gates.tests.command,
+      commandProvenance: {
+        command: gates.tests.command,
+        cwd: options.cwd,
+        source: options.source ?? "deterministic-gate"
+      },
+      failingTests: gates.tests.failingTests,
+      ...gates.tests.failingTestIdentities ? { failingTestIdentities: gates.tests.failingTestIdentities } : {},
+      ...testTotals ?? {},
+      verificationCoverage: gates.tests.verificationCoverage,
+      commandResults: gates.tests.commandResults
+    } : void 0
+  };
+}
+function comparableTestTotals(tests) {
+  const evidence = tests.commandResults && tests.commandResults.length > 0 ? tests.commandResults.map((result) => ({
+    command: result.command,
+    output: result.outputTail
+  })) : [{ command: tests.command, output: tests.outputTail }];
+  let testsRun = 0;
+  let testsPassed = 0;
+  let testsSkipped = 0;
+  for (const item of evidence) {
+    const parsed = parseFailureOutput(item.command, item.output, "test");
+    if (!parsed.parsed || parsed.errorCount === null || !parsed.suiteFootprint) {
+      return void 0;
+    }
+    testsRun += parsed.suiteFootprint.executed + parsed.suiteFootprint.skipped;
+    testsPassed += Math.max(0, parsed.suiteFootprint.executed - parsed.errorCount);
+    testsSkipped += parsed.suiteFootprint.skipped;
+  }
+  return { testsRun, testsPassed, testsSkipped };
+}
+
+// src/core/verification/baseline-comparison.ts
+var VALID_VERIFICATION_LANGUAGES = /* @__PURE__ */ new Set([
+  "node",
+  "python",
+  "native",
+  "go",
+  "rust",
+  "jvm",
+  "dotnet",
+  "swift",
+  "dart",
+  "ruby",
+  "php",
+  "shell",
+  "r",
+  "sql",
+  "unknown"
+]);
+function languageFor(value) {
+  if (value == null || value.length === 0) return "unknown";
+  return VALID_VERIFICATION_LANGUAGES.has(value) ? value : "unknown";
+}
+function generateSummaryMessage(comparison) {
+  const parts = [];
+  const totalNew = comparison.tests.newFailures.length + comparison.types.newFailures.length + comparison.lint.newFailures.length;
+  const totalFixed = comparison.tests.fixedIssues.length + comparison.types.fixedIssues.length + comparison.lint.fixedIssues.length;
+  const totalPersisting = comparison.tests.persistingIssues.length + comparison.types.persistingIssues.length + comparison.lint.persistingIssues.length;
+  switch (comparison.verdict) {
+    case "pass":
+      parts.push("No verification issues");
+      break;
+    case "regression":
+      parts.push(`Introduced ${totalNew} new failure(s)`);
+      if (comparison.tests.newFailures.length > 0) {
+        parts.push(`  - ${comparison.tests.newFailures.length} test failure(s)`);
+      }
+      if (comparison.types.newFailures.length > 0) {
+        parts.push(`  - ${comparison.types.newFailures.length} type error(s)`);
+      }
+      if (comparison.lint.newFailures.length > 0) {
+        parts.push(`  - ${comparison.lint.newFailures.length} lint error(s)`);
+      }
+      break;
+    case "improvement":
+      parts.push(`Fixed ${totalFixed} pre-existing issue(s)`);
+      break;
+    case "neutral":
+      parts.push(`No change (${totalPersisting} pre-existing issue(s) unchanged)`);
+      break;
+    case "comparison-unavailable":
+      parts.push(
+        "Baseline comparison unavailable: execution or issue identity could not be established"
+      );
+      break;
+  }
+  if (totalPersisting > 0 && comparison.verdict !== "neutral" && comparison.verdict !== "comparison-unavailable") {
+    parts.push(`${totalPersisting} pre-existing issue(s) not penalized`);
+  }
+  return parts.join("\n");
+}
+function statusDidNotRun(status) {
+  return status === "skipped" || status === "unavailable" || status === "not_run";
+}
+function detectGateRegressions(baseline, currentGates, baselineState) {
+  const build = currentGates.build != null && !statusDidNotRun(currentGates.build.status) && currentGates.build.exitCode !== 0 && baseline.typeErrors.exitCode === 0 && baselineState.gates.build.availability !== "unavailable";
+  const lint = currentGates.lint != null && !statusDidNotRun(currentGates.lint.status) && currentGates.lint.exitCode !== 0 && baseline.lintErrors.exitCode === 0 && baselineState.gates.lint.availability !== "unavailable";
+  const test = currentGates.tests != null && !statusDidNotRun(currentGates.tests.status) && currentGates.tests.exitCode !== 0 && baseline.testResults.exitCode === 0 && baselineState.gates.test.availability !== "unavailable";
+  return {
+    build,
+    lint,
+    test,
+    total: Number(build) + Number(lint) + Number(test)
+  };
+}
+function statusFromCommandSummaryExitCode(exitCode) {
+  if (exitCode === 0) return "passed";
+  if (exitCode === 124) return "timeout";
+  return "failed";
+}
+function commandResultsFromSummaries(commands) {
+  if (!commands || commands.length === 0) return void 0;
+  return commands.map((command) => ({
+    command: command.command,
+    language: languageFor(command.language),
+    status: command.status ?? statusFromCommandSummaryExitCode(command.exitCode),
+    exitCode: command.exitCode,
+    outputTail: command.outputTail,
+    parsed: command.parsed,
+    failingTests: command.failedTests
+  }));
+}
+function matchedExecutedCommandIssues(channel, baselineCommands, currentCommands) {
+  const key = (command) => `${command.language}\0${command.command}`;
+  const baselineByCommand = new Map(
+    (commandResultsFromSummaries(baselineCommands) ?? []).filter((command) => command.command.trim() && !statusDidNotRun(command.status)).map((command) => [key(command), command])
+  );
+  const current = (currentCommands ?? []).filter(
+    (command) => !statusDidNotRun(command.status) && baselineByCommand.has(key(command))
+  );
+  const baseline = current.map((command) => baselineByCommand.get(key(command)));
+  const issues = (commands) => {
+    const representative = commands.find((command) => command.exitCode !== 0) ?? commands[0];
+    if (!representative) return new IssueSet();
+    const gate = {
+      ...representative,
+      failingTests: representative.failingTestIdentities ?? representative.failingTests ?? [],
+      commandResults: commands
+    };
+    const state = extractStableVerificationState({
+      [channel === "test" ? "tests" : channel]: gate
+    });
+    return channel === "build" ? state.buildIssues : channel === "lint" ? state.lintIssues : state.testIssues;
+  };
+  return [issues(baseline), issues(current)];
+}
+function baselineToStableState(baseline) {
+  const buildCommands = baseline.summary?.gates.build.commands;
+  const lintCommands = baseline.summary?.gates.lint.commands;
+  const testCommands = baseline.summary?.gates.test.commands;
+  const multiBuild = buildCommands && buildCommands.length > 1;
+  const multiLint = lintCommands && lintCommands.length > 1;
+  const multiTest = testCommands && testCommands.length > 1;
+  const singleBuild = buildCommands && buildCommands.length === 1 ? buildCommands[0] : void 0;
+  const singleLint = lintCommands && lintCommands.length === 1 ? lintCommands[0] : void 0;
+  const singleTest = testCommands && testCommands.length === 1 ? testCommands[0] : void 0;
+  const state = extractStableVerificationState({
+    build: {
+      status: baseline.summary?.gates.build.availability === "unavailable" ? "unavailable" : baseline.summary?.gates.build.availability === "out_of_scope" ? "skipped" : singleBuild?.status,
+      exitCode: multiBuild ? buildCommands.some((c) => c.exitCode !== 0) ? 1 : 0 : singleBuild?.exitCode ?? baseline.typeErrors.exitCode,
+      outputTail: multiBuild ? "" : singleBuild?.outputTail ?? baseline.typeErrors.outputTail,
+      language: languageFor(
+        multiBuild ? baseline.summary?.gates.build.language : singleBuild?.language ?? baseline.summary?.gates.build.language
+      ),
+      commandResults: multiBuild ? commandResultsFromSummaries(buildCommands) : void 0
+    },
+    lint: {
+      status: baseline.summary?.gates.lint.availability === "unavailable" ? "unavailable" : baseline.summary?.gates.lint.availability === "out_of_scope" ? "skipped" : singleLint?.status,
+      exitCode: multiLint ? lintCommands.some((c) => c.exitCode !== 0) ? 1 : 0 : singleLint?.exitCode ?? baseline.lintErrors.exitCode,
+      outputTail: multiLint ? "" : singleLint?.outputTail ?? baseline.lintErrors.outputTail,
+      language: languageFor(
+        multiLint ? baseline.summary?.gates.lint.language : singleLint?.language ?? baseline.summary?.gates.lint.language
+      ),
+      commandResults: multiLint ? commandResultsFromSummaries(lintCommands) : void 0
+    },
+    tests: {
+      status: baseline.summary?.gates.test.availability === "unavailable" ? "unavailable" : baseline.summary?.gates.test.availability === "out_of_scope" ? "skipped" : singleTest?.status,
+      exitCode: multiTest ? testCommands.some((c) => c.exitCode !== 0) ? 1 : 0 : singleTest?.exitCode ?? baseline.testResults.exitCode,
+      outputTail: multiTest ? "" : singleTest?.outputTail ?? baseline.testResults.outputTail,
+      language: languageFor(
+        multiTest ? baseline.summary?.gates.test.language : singleTest?.language ?? baseline.summary?.gates.test.language
+      ),
+      failingTests: multiTest ? Array.from(new Set(testCommands.flatMap((c) => c.failedTests ?? []))) : singleTest?.failedTests ?? baseline.testResults.failedTests,
+      commandResults: multiTest ? commandResultsFromSummaries(testCommands) : void 0
+    }
+  });
+  if (!multiBuild && !multiLint && !multiTest && !singleBuild && !singleLint && !singleTest) {
+    const buildFailed = baseline.typeErrors.exitCode !== 0 && !state.gates.build.unavailable && state.gates.build.availability !== "out_of_scope";
+    const lintFailed = baseline.lintErrors.exitCode !== 0 && !state.gates.lint.unavailable && state.gates.lint.availability !== "out_of_scope";
+    const testFailed = baseline.testResults.exitCode !== 0 && !state.gates.test.unavailable && state.gates.test.availability !== "out_of_scope";
+    const buildIssues = parseVerificationErrorsForChannel(
+      "build",
+      languageFor(baseline.summary?.gates.build.language),
+      state.gates.build.availability === "executed" ? baseline.typeErrors.outputTail : "",
+      buildFailed
+    ).issues;
+    const lintIssues = parseVerificationErrorsForChannel(
+      "lint",
+      languageFor(baseline.summary?.gates.lint.language),
+      state.gates.lint.availability === "executed" ? baseline.lintErrors.outputTail : "",
+      lintFailed
+    ).issues;
+    const testIssues = parseVerificationErrorsForChannel(
+      "test",
+      languageFor(baseline.summary?.gates.test.language),
+      state.gates.test.availability === "executed" ? baseline.testResults.outputTail : "",
+      testFailed,
+      state.gates.test.availability === "executed" ? baseline.testResults.failedTests : []
+    ).issues;
+    return {
+      buildIssues,
+      lintIssues,
+      testIssues,
+      totalIssues: buildIssues.size + lintIssues.size + testIssues.size,
+      gates: state.gates
+    };
+  }
+  return state;
+}
+function determineStableVerdict(delta) {
+  if (delta.hasAnyRegressions) {
+    return "regression";
+  }
+  if (delta.hasAnyImprovements) {
+    return "improvement";
+  }
+  if (delta.totalPersistingIssues > 0) {
+    return "neutral";
+  }
+  return "pass";
+}
+function formatStableIssueLabel(issue) {
+  if (issue.gate === "test") {
+    return issue.file ? `${issue.file}: ${issue.code}` : issue.code;
+  }
+  const loc = issue.line ? `:${issue.line}${issue.col ? `:${issue.col}` : ""}` : "";
+  if (issue.originalMessage) {
+    return `${issue.file}${loc}: ${issue.code} - ${issue.originalMessage}`;
+  }
+  return `${issue.file}${loc}: ${issue.code}`;
+}
+function issueSetToDimensionComparison(issueDelta) {
+  return {
+    newFailures: issueDelta.newIssues.toArray().map(formatStableIssueLabel),
+    fixedIssues: issueDelta.fixedIssues.toArray().map(formatStableIssueLabel),
+    persistingIssues: issueDelta.persistingIssues.toArray().map(formatStableIssueLabel),
+    netChange: issueDelta.netChange
+  };
+}
+function stableComparisonToBaselineComparison(stable) {
+  const tests = issueSetToDimensionComparison(stable.delta.test);
+  const types = issueSetToDimensionComparison(stable.delta.build);
+  const lint = issueSetToDimensionComparison(stable.delta.lint);
+  const totalNewFailures = tests.newFailures.length + types.newFailures.length + lint.newFailures.length;
+  const totalFixedIssues = tests.fixedIssues.length + types.fixedIssues.length + lint.fixedIssues.length;
+  const totalPersistingIssues = tests.persistingIssues.length + types.persistingIssues.length + lint.persistingIssues.length;
+  return {
+    verdict: stable.verdict,
+    tests,
+    types,
+    lint,
+    summary: {
+      totalNewFailures,
+      totalFixedIssues,
+      totalPersistingIssues,
+      // `shouldPenalize` keeps its documented meaning: PROVEN new failures, so a proven
+      // regression stays penalisable even when a sibling channel's identity gap is also
+      // reported. Uncertainty alone never penalises — `comparisonUnavailable` carries it
+      // instead, and `baselineComparisonProvesClean` keeps it out of clean promotions.
+      shouldPenalize: stable.provenNewFailures,
+      comparisonUnavailable: stable.comparisonIdentityUnavailable || (stable.comparisonExecutionUnavailableChannels?.length ?? 0) > 0,
+      comparisonUnavailableChannels: ["build", "lint", "test"].filter(
+        (channel) => stable.comparisonIdentityUnavailableChannels.includes(channel) || (stable.comparisonExecutionUnavailableChannels ?? []).includes(channel)
+      ),
+      comparisonIdentityUnavailableChannels: [...stable.comparisonIdentityUnavailableChannels],
+      // Only a skipped or absent test run is substituted; an unavailable one is already
+      // an execution gap on the test channel.
+      ...stable.testVerificationUnavailable && !(stable.comparisonExecutionUnavailableChannels ?? []).includes("test") ? { testChannelNotCompared: true } : {},
+      scoreAdjustment: 0,
+      message: generateSummaryMessage({ verdict: stable.verdict, tests, types, lint })
+    },
+    baselineRef: stable.baselineRef
+  };
+}
+function compareVerificationOutcomeToBaseline(baseline, currentGates) {
+  return compareCurrentGatesToBaseline(baseline, currentGates);
+}
+function compareCurrentGatesToBaseline(baseline, currentGates) {
+  const baselineState = baselineToStableState(baseline);
+  const currentState = extractStableVerificationState(currentGates);
+  const testVerificationUnavailable = currentGates.tests == null || currentGates.tests.status === "skipped" || currentGates.tests.status === "unavailable" || currentGates.tests.status === "not_run";
+  if (testVerificationUnavailable && currentGates.tests?.status !== "unavailable" && currentGates.tests?.status !== "not_run") {
+    currentState.testIssues = baselineState.testIssues;
+    currentState.totalIssues = currentState.buildIssues.size + currentState.lintIssues.size + currentState.testIssues.size;
+  }
+  const comparisonExecutionUnavailableChannels = ["build", "lint", "test"].filter(
+    (channel) => baselineState.gates[channel].availability === "unavailable" || currentState.gates[channel].availability === "unavailable"
+  );
+  const comparableBaseline = { ...baselineState };
+  const comparableCurrent = { ...currentState };
+  for (const channel of comparisonExecutionUnavailableChannels) {
+    const key = channel === "build" ? "buildIssues" : channel === "lint" ? "lintIssues" : "testIssues";
+    const baselineCommands = baseline.summary?.gates[channel].commands;
+    const currentGate = currentGates[channel === "test" ? "tests" : channel];
+    const currentCommands = currentGate?.commandResults ?? (currentGate?.command?.trim() && currentGate.language !== "unknown" && !statusDidNotRun(currentGate.status) ? [
+      {
+        ...currentGate,
+        command: currentGate.command,
+        status: currentGate.status === "not_run" ? "unavailable" : currentGate.status
+      }
+    ] : void 0);
+    if (baselineState.gates[channel].availability === "unavailable" || baselineCommands?.length && currentCommands?.length) {
+      [comparableBaseline[key], comparableCurrent[key]] = matchedExecutedCommandIssues(
+        channel,
+        baselineCommands,
+        currentCommands
+      );
+    } else if (currentState[key].size === 0) {
+      comparableBaseline[key] = new IssueSet();
+      comparableCurrent[key] = new IssueSet();
+    }
+  }
+  const delta = compareVerificationStates(comparableBaseline, comparableCurrent);
+  const baseVerdict = determineStableVerdict(delta);
+  const gateRegressions = detectGateRegressions(baseline, currentGates, baselineState);
+  const comparableTestTotalRegressed = !testVerificationUnavailable && baselineState.gates.test.availability !== "unavailable" && baseline.testResults.run !== void 0 && currentGates.tests?.testsRun !== void 0 && currentGates.tests.testsRun < baseline.testResults.run;
+  const gateRegressed = gateRegressions.total > 0 || comparableTestTotalRegressed;
+  const identity = assessComparisonIdentityAvailability(delta, {
+    build: {
+      language: currentGates.build?.language,
+      skip: currentGates.build?.status === "timeout"
+    },
+    lint: {
+      language: currentGates.lint?.language,
+      skip: currentGates.lint?.status === "timeout"
+    },
+    test: {
+      language: currentGates.tests?.language,
+      skip: testVerificationUnavailable || currentGates.tests?.status === "timeout"
+    }
+  });
+  const provenNewFailures = delta.hasAnyRegressions || gateRegressed;
+  const comparisonIdentityUnavailable = identity.unavailable;
+  const verdict = provenNewFailures ? "regression" : comparisonIdentityUnavailable || comparisonExecutionUnavailableChannels.length > 0 ? "comparison-unavailable" : baseVerdict;
+  return {
+    delta,
+    baseline: baselineState,
+    current: currentState,
+    baselineRef: baseline.baselineRef,
+    passed: !provenNewFailures && !comparisonIdentityUnavailable && comparisonExecutionUnavailableChannels.length === 0,
+    testVerificationUnavailable,
+    comparisonExecutionUnavailableChannels,
+    comparisonIdentityUnavailable,
+    comparisonIdentityUnavailableChannels: identity.channels,
+    ...comparisonIdentityUnavailable && identity.reason ? { comparisonIdentityUnavailableReason: identity.reason } : {},
+    provenNewFailures,
+    comparableTestTotalRegressed,
+    verdict,
+    scoreAdjustment: 0
+  };
+}
+
+// src/core/verification/baseline-attribution.ts
+function baseOnlyIssuesByGate(comparison, identicalToBase = []) {
+  const only = (gate, issues) => {
+    if (issues.newIssues.size > 0) return [];
+    const labels = issues.persistingIssues.toArray().map(formatStableIssueLabel);
+    return labels.length === 0 && identicalToBase.includes(gate) ? [identicalToBaseLabel(gate)] : labels;
+  };
+  const { build, lint, test } = comparison.delta;
+  return { build: only("build", build), lint: only("lint", lint), test: only("test", test) };
+}
+function persistingIssuesOnBase(comparison, baseline, gates) {
+  return baseOnlyIssuesByGate(
+    comparison,
+    baseline ? channelsFailingIdenticallyOnBase(baseline, gates, ["lint"]) : []
+  );
+}
+function identicalToBaseLabel(gate) {
+  return `${gate} failure identical to the base commit`;
+}
+function markLintIdenticalToBase(comparison, identicalToBase) {
+  const { lint, summary } = comparison;
+  if (lint && identicalToBase.includes("lint") && lint.newFailures.length === 0 && lint.persistingIssues.length === 0) {
+    lint.persistingIssues = [identicalToBaseLabel("lint")];
+    summary.totalPersistingIssues += 1;
+    const notLint = (channels) => channels?.filter((c) => c !== "lint");
+    summary.comparisonIdentityUnavailableChannels = notLint(
+      summary.comparisonIdentityUnavailableChannels
+    );
+    summary.comparisonUnavailableChannels = notLint(summary.comparisonUnavailableChannels);
+    if (summary.comparisonUnavailable && !summary.comparisonUnavailableChannels?.length) {
+      summary.comparisonUnavailable = false;
+      if (comparison.verdict === "comparison-unavailable") comparison.verdict = "neutral";
+    }
+  }
+  return comparison;
+}
+function trustedLoopBaselineComparison(baselineRef, last) {
+  const persisting = last.persistingIssues ?? { build: [], lint: [], test: [] };
+  return {
+    verdict: "pass",
+    baselineRef,
+    summary: {
+      totalNewFailures: 0,
+      totalFixedIssues: last.fixedIssueCount ?? 0,
+      totalPersistingIssues: Object.values(persisting).flat().length,
+      shouldPenalize: false,
+      // A trusted verification-loop pass IS an established comparison.
+      comparisonUnavailable: false,
+      scoreAdjustment: 0,
+      message: "Verification loop passed baseline comparison"
+    },
+    tests: { newFailures: [], fixedIssues: [], persistingIssues: persisting.test },
+    types: { newFailures: [], fixedIssues: [], persistingIssues: persisting.build },
+    lint: { newFailures: [], fixedIssues: [], persistingIssues: persisting.lint }
+  };
+}
+function variantGatesAlsoFailingOnBase(variant) {
+  const outcome = variant.outcome?.verification;
+  return failedGatesAlsoFailingOnBase(variant.baselineComparison, {
+    buildStatus: variant.buildStatus ?? outcome?.buildStatus,
+    lintStatus: variant.lintStatus ?? outcome?.lintStatus,
+    testStatus: variant.testStatus ?? outcome?.testStatus
+  });
+}
+function failedGatesAlsoFailingOnBase(comparison, gates) {
+  if (!comparison) return [];
+  const dimensions = [
+    ["build", gates.buildStatus, comparison.types],
+    ["lint", gates.lintStatus, comparison.lint],
+    ["test", gates.testStatus, comparison.tests]
+  ];
+  return dimensions.filter(
+    ([, status, dimension]) => status === "failed" && dimension !== void 0 && dimension.newFailures.length === 0 && dimension.persistingIssues.length > 0
+  ).map(([gate]) => gate);
+}
+
+// src/core/verification/baseline-clean-claim.ts
+function baselineComparisonProvesClean(comparison) {
+  if (!comparison) return false;
+  return comparison.summary.shouldPenalize === false && comparison.summary.comparisonUnavailable !== true;
+}
+function baselineComparisonProvesCleanForChannels(comparison, channels) {
+  if (!comparison || comparison.summary.shouldPenalize !== false) return false;
+  if (channels.includes("test") && comparison.summary.testChannelNotCompared === true) {
+    return false;
+  }
+  if (comparison.summary.comparisonUnavailable !== true) return true;
+  const gaps = comparison.summary.comparisonUnavailableChannels;
+  const identityGaps = comparison.summary.comparisonIdentityUnavailableChannels;
+  if (!gaps || !identityGaps) return false;
+  const identityBlocks = identityGaps.some(
+    (channel) => channel !== "lint" || channels.includes("lint")
+  );
+  const executionBlocks = gaps.some(
+    (channel) => !identityGaps.includes(channel) && channels.includes(channel)
+  );
+  return !identityBlocks && !executionBlocks;
+}
+function stableBaselineProvesClean(comparison, provenNewFailures, hardChannels) {
+  const identityGap = [
+    ...comparison.comparisonIdentityUnavailableChannels,
+    ...comparison.comparisonExecutionUnavailableChannels ?? []
+  ].some((channel) => hardChannels.includes(channel));
+  return baselineComparisonProvesClean({
+    summary: { shouldPenalize: provenNewFailures, comparisonUnavailable: identityGap }
+  });
+}
+function applyKnownFailureDowngrade(comparison, downgradedFailureCount) {
+  comparison.summary.shouldPenalize = false;
+  const identityStillUnavailable = comparison.summary.comparisonUnavailable === true;
+  comparison.verdict = identityStillUnavailable ? "comparison-unavailable" : "neutral";
+  const note = identityStillUnavailable ? `[registry] All ${downgradedFailureCount} new test failure(s) matched known-pre-existing-failures registry, but the baseline comparison remains unavailable: issue identity could not be established.` : `[registry] All ${downgradedFailureCount} new test failure(s) matched known-pre-existing-failures registry \u2014 downgraded to baseline_clean.`;
+  comparison.summary.message = [comparison.summary.message, note].filter(Boolean).join("\n");
+}
+
+// src/core/project/direct-test-command.ts
+var OPAQUE_VERIFICATION_WRAPPER_HEADS = /* @__PURE__ */ new Set([
+  "make",
+  "just",
+  "task",
+  "turbo",
+  "nx",
+  "npm",
+  "pnpm",
+  "yarn",
+  "bun",
+  "npx",
+  "pnpx",
+  "bunx",
+  "composer",
+  "rake"
+]);
+var EXEC_LAUNCHER_PREFIX = /^(?:bundle\s+exec|poetry\s+run|uv\s+run|pipenv\s+run|pdm\s+run|hatch\s+run)\s+/i;
+function commandHeadBase(command) {
+  const head = command.trim().split(/\s+/)[0] ?? "";
+  return head.replace(/^.*[/\\]/, "").replace(/\.(?:cmd|exe|bat)$/i, "").toLowerCase();
+}
+function isOpaqueVerificationWrapper(command) {
+  if (OPAQUE_VERIFICATION_WRAPPER_HEADS.has(commandHeadBase(command))) return true;
+  const nested = command.trim().replace(EXEC_LAUNCHER_PREFIX, "");
+  return nested !== command.trim() && OPAQUE_VERIFICATION_WRAPPER_HEADS.has(commandHeadBase(nested));
+}
+function isDirectTestCommand(command) {
+  if (!command.trim() || isOpaqueVerificationWrapper(command)) return false;
+  const descriptor = describeVerificationCommand(command);
+  return descriptor.language !== "unknown" && descriptor.kind === "test";
+}
+
+// src/core/judge/test-command-output.ts
+function inferSuccessStatusFromMetrics(metrics) {
+  if (metrics.testsRun === 0) {
+    return "error";
+  }
+  return metrics.testsFailed === 0 ? "passed" : "failed";
+}
+function classifyExitZeroTestMetrics(command, metrics) {
+  if (metrics.testsFailed > 0) return "failed";
+  if (metrics.metricsMeasured) {
+    const measured = inferSuccessStatusFromMetrics(metrics);
+    if (measured !== "error") return measured;
+  }
+  if (metrics.successProse && isDirectTestCommand(command)) return "passed";
+  return "unavailable";
+}
+function classifyTestCommandOutput(command, output, exitCode) {
+  if (exitCode === 0 ? detectEmptyRun(command, output, 0, { bucket: "test" }) : detectZeroCollectedTests(command, output, { bucket: "test" })) {
+    return {
+      status: "unavailable",
+      testsRun: 0,
+      testsPassed: 0,
+      testsFailed: 0,
+      metricsMeasured: false
+    };
+  }
+  const metrics = parseGenericPassFailOutput(output, command);
+  if (exitCode === 0) {
+    const status = classifyExitZeroTestMetrics(command, metrics);
+    if (status === "unavailable") {
+      return {
+        status,
+        testsRun: 0,
+        testsPassed: 0,
+        testsFailed: 0,
+        metricsMeasured: false
+      };
+    }
+    return {
+      status,
+      testsRun: metrics.testsRun,
+      testsPassed: metrics.testsPassed,
+      testsFailed: metrics.testsFailed,
+      metricsMeasured: metrics.metricsMeasured
+    };
+  }
+  if (metrics.testsFailed > 0 || metrics.testsRun >= 1) {
+    return {
+      status: "failed",
+      testsRun: metrics.testsRun,
+      testsPassed: metrics.testsPassed,
+      testsFailed: metrics.testsFailed,
+      metricsMeasured: metrics.metricsMeasured
+    };
+  }
+  return {
+    status: "unavailable",
+    testsRun: 0,
+    testsPassed: 0,
+    testsFailed: 0,
+    metricsMeasured: false
+  };
+}
+
+// src/core/judge/test-provenance.ts
+function recordedTestResultPredatesRepair(variant) {
+  const repair = variant.repairOutcome;
+  return repair?.attempted === true && repair.classification !== "none";
+}
+function hasTestExecutionProvenance(variant) {
+  const testsExecuted = variant.testsExecuted;
+  if (!testsExecuted || testsExecuted.scope === "none") return false;
+  return true;
+}
+var RECORDED_TEST_STATUSES = /* @__PURE__ */ new Set(["passed", "failed", "error", "timeout", "not_run"]);
+function normalizeRecordedTestStatus(status) {
+  if (typeof status !== "string") return void 0;
+  const normalized = status.trim().toLowerCase();
+  if (normalized === "unavailable") return "not_run";
+  return RECORDED_TEST_STATUSES.has(normalized) ? normalized : void 0;
+}
+function hasUnrecognizedRecordedTestStatus(status) {
+  if (typeof status !== "string") return false;
+  return normalizeRecordedTestStatus(status) === void 0;
+}
+function hasRecordedTestExecutionEvidence(params) {
+  const hasCommand = (params.command?.trim().length ?? 0) > 0;
+  const hasFiles = (params.filesTested?.length ?? 0) > 0;
+  const hasTestCount = params.totalTests > 0;
+  if (hasCommand && params.exitCode !== void 0 && params.exitCode !== 0) {
+    return true;
+  }
+  const signalCount = (hasCommand ? 1 : 0) + (hasFiles ? 1 : 0) + (hasTestCount ? 1 : 0);
+  return signalCount >= 2;
+}
+function recordedTestCommands(command, commands) {
+  const split = (value) => value.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  const fromCommand = split(command ?? "");
+  if (fromCommand.length > 0) return fromCommand;
+  return (commands ?? []).flatMap(split);
+}
+function isDirectRunnerCleanPassRecord(params) {
+  if (!params.scope || params.scope === "none") return false;
+  if (params.skipReason) return false;
+  if (params.exitCode !== 0) return false;
+  if (normalizeRecordedTestStatus(params.testStatus) !== "passed") return false;
+  const commands = recordedTestCommands(params.command, params.commands);
+  if (commands.length !== 1) return false;
+  const [command] = commands;
+  if (!isDirectTestCommand(command) || !params.outputTail?.trim()) return false;
+  return classifyTestCommandOutput(command, params.outputTail, 0).status === "passed";
+}
+function isUnavailableStatus(status) {
+  return status === "unavailable";
+}
+function hasUnavailableCoverage(gate) {
+  if (typeof gate !== "object" || gate === null) {
+    return false;
+  }
+  const verificationCoverage = gate.verificationCoverage;
+  if (typeof verificationCoverage !== "object" || verificationCoverage === null) {
+    return false;
+  }
+  return verificationCoverage.status === "skipped_tool_unavailable";
+}
+function hasUnavailableGateEvidence(gate) {
+  if (typeof gate !== "object" || gate === null) {
+    return false;
+  }
+  return isUnavailableStatus(gate.status) || hasUnavailableCoverage(gate);
+}
+function latestVerificationIteration(loop) {
+  if (!loop?.enabled || !Array.isArray(loop.iterations) || loop.iterations.length === 0) {
+    return null;
+  }
+  return loop.iterations.reduce(
+    (best, current) => (current.iteration ?? 0) > (best.iteration ?? 0) ? current : best
+  );
+}
+function hasUnavailableVerificationGateEvidence(variant) {
+  if (variant.verification?.status === "unavailable") {
+    return true;
+  }
+  const last = latestVerificationIteration(variant.verificationLoop);
+  if (hasUnavailableGateEvidence(last?.build) || hasUnavailableGateEvidence(last?.lint) || hasUnavailableGateEvidence(last?.tests)) {
+    return true;
+  }
+  if (isUnavailableStatus(variant.testStatus)) {
+    return true;
+  }
+  return variant.testsExecuted?.skipReason === "verification-unavailable";
+}
+function isNoCoveringCommandGate(gate) {
+  if (typeof gate !== "object" || gate === null) return false;
+  const { status, verificationCoverage } = gate;
+  return isUnavailableStatus(status) && verificationCoverage?.status === "skipped_no_command";
+}
+function hasVetoingUnavailableVerificationGateEvidence(variant) {
+  if (!hasUnavailableVerificationGateEvidence(variant)) return false;
+  if (variant.verification?.status === "unavailable") return true;
+  if (hasUnavailableTestVerificationEvidence(variant)) return true;
+  const last = latestVerificationIteration(variant.verificationLoop);
+  if (!last || last.tests?.status !== "passed" || last.tests.exitCode !== 0) return true;
+  if (last.tests.testsRun === 0) return true;
+  return [last.build, last.lint].some(
+    (gate) => hasUnavailableGateEvidence(gate) && !isNoCoveringCommandGate(gate)
+  );
+}
+function hasUnavailableTestVerificationEvidence(variant) {
+  const last = latestVerificationIteration(variant.verificationLoop);
+  if (hasUnavailableGateEvidence(last?.tests)) return true;
+  if (isUnavailableStatus(variant.testStatus)) {
+    return true;
+  }
+  return variant.testsExecuted?.skipReason === "verification-unavailable";
+}
+
+// src/utils/structured-logger.ts
+var StructuredLogger = class _StructuredLogger {
+  component;
+  /**
+   * Create a new structured logger
+   *
+   * @param component - Component or module name for log identification
+   */
+  constructor(component) {
+    this.component = component;
+  }
+  /**
+   * Internal logging method that creates structured log entries
+   *
+   * @param level - Log severity level
+   * @param message - Human-readable message
+   * @param context - Additional structured context
+   * @param error - Error object (for error-level logs)
+   */
+  log(level, message, context, error) {
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      component: this.component,
+      message,
+      context: { ...context }
+    };
+    if (error) {
+      entry.error = {
+        message: error.message,
+        stack: error.stack,
+        name: error.name,
+        // Include error code if present (common in Node.js errors)
+        code: "code" in error ? String(error.code) : void 0
+      };
+    }
+    const formatted = JSON.stringify(entry);
+    switch (level) {
+      case "debug":
+        if (isTelemetryDebug() || process.env.DEBUG === "build:*") {
+          console.debug(formatted);
+        }
+        break;
+      case "info":
+        console.log(formatted);
+        break;
+      case "warn":
+        console.warn(formatted);
+        break;
+      case "error":
+        console.error(formatted);
+        break;
+    }
+  }
+  /**
+   * Log debug message (only visible when BUILD_DEBUG_TELEMETRY=1)
+   *
+   * @param message - Debug message
+   * @param context - Additional context
+   */
+  debug(message, context) {
+    this.log("debug", message, context);
+  }
+  /**
+   * Log informational message
+   *
+   * @param message - Info message
+   * @param context - Additional context
+   */
+  info(message, context) {
+    this.log("info", message, context);
+  }
+  /**
+   * Log warning message
+   *
+   * @param message - Warning message
+   * @param context - Additional context
+   */
+  warn(message, context) {
+    this.log("warn", message, context);
+  }
+  /**
+   * Log error message with optional error object
+   *
+   * @param message - Error message
+   * @param error - Error object (optional)
+   * @param context - Additional context
+   */
+  error(message, error, context) {
+    this.log("error", message, context, error);
+  }
+  /**
+   * Create a child logger with additional context
+   *
+   * Useful for adding persistent context to all logs from a specific operation.
+   *
+   * @param childComponent - Child component name (appended to parent)
+   * @returns New logger instance
+   *
+   * @example
+   * ```typescript
+   * const masterLogger = new StructuredLogger('CompetitionMaster');
+   * const variantLogger = masterLogger.child('VariantExecution');
+   * // Logs will show component as 'CompetitionMaster:VariantExecution'
+   * ```
+   */
+  child(childComponent) {
+    return new _StructuredLogger(`${this.component}:${childComponent}`);
+  }
+  /**
+   * Measure and log operation duration
+   *
+   * @param operation - Operation name
+   * @param fn - Function to measure
+   * @returns Function result
+   *
+   * @example
+   * ```typescript
+   * const result = await logger.measure('database_query', async () => {
+   *   return await db.query('SELECT * FROM variants');
+   * });
+   * // Logs: "Operation completed: database_query (duration_ms: 145)"
+   * ```
+   */
+  async measure(operation, fn) {
+    const startTime = Date.now();
+    this.debug(`Operation started: ${operation}`);
+    try {
+      const result = await fn();
+      const duration = Date.now() - startTime;
+      this.debug(`Operation completed: ${operation}`, { duration_ms: duration });
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      this.error(`Operation failed: ${operation}`, error, { duration_ms: duration });
+      throw error;
+    }
+  }
+  /**
+   * Measure synchronous operation duration
+   *
+   * @param operation - Operation name
+   * @param fn - Function to measure
+   * @returns Function result
+   */
+  measureSync(operation, fn) {
+    const startTime = Date.now();
+    this.debug(`Operation started: ${operation}`);
+    try {
+      const result = fn();
+      const duration = Date.now() - startTime;
+      this.debug(`Operation completed: ${operation}`, { duration_ms: duration });
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      this.error(`Operation failed: ${operation}`, error, { duration_ms: duration });
+      throw error;
+    }
+  }
+};
+function createLogger(component) {
+  return new StructuredLogger(component);
+}
+
+// src/core/synthesis/ignored-planning-artifact-path.ts
+function normalizeIgnoredArtifactPath(candidate) {
+  let normalized = candidate.trim().replace(/\\/g, "/");
+  if (!normalized) return null;
+  while (normalized.startsWith("./")) {
+    normalized = normalized.slice(2);
+  }
+  if (normalized.startsWith("/")) {
+    const marker = "/.build-project/planning";
+    const markerIndex = normalized.indexOf(marker);
+    if (markerIndex < 0) return null;
+    normalized = normalized.slice(markerIndex + 1);
+  }
+  const parts = [];
+  for (const part of normalized.split("/")) {
+    if (!part || part === ".") continue;
+    if (part === "..") {
+      if (parts.length === 0) return null;
+      parts.pop();
+      continue;
+    }
+    parts.push(part);
+  }
+  return parts.length > 0 ? parts.join("/") : null;
+}
+function isIgnoredPlanningArtifactPath(candidate) {
+  const normalized = normalizeIgnoredArtifactPath(candidate);
+  return normalized === ".build-project/planning" || normalized?.startsWith(".build-project/planning/") === true;
+}
+
+// src/core/judge/executed-gate-failure.ts
+var TOOL_NOT_FOUND_EXIT_CODES = /* @__PURE__ */ new Set([126, 127]);
+function isToolNotFoundExit(exitCode) {
+  return exitCode !== void 0 && TOOL_NOT_FOUND_EXIT_CODES.has(exitCode);
+}
+function hasRecordedExecutedTestFailure(result) {
+  const exitCode = result.testsExecuted?.exitCode;
+  return (result.testStatus === "failed" || result.testStatus === "timeout") && typeof exitCode === "number" && exitCode !== 0 && !isToolNotFoundExit(exitCode);
+}
+function reportsUnavailableTool(exitCode, outputTail = "", unavailableReason) {
+  return isToolNotFoundExit(exitCode) || isUnavailableVerificationFinding({ severity: "warning", outputTail, unavailableReason }) || wrapperReportsInnerMissingLaunch(outputTail) || exitCode === void 0 && /\bcommand not found\b/i.test(outputTail);
+}
+function isConcreteGateFailure(gate) {
+  if (gate?.status !== "failed" && gate?.status !== "error" && gate?.status !== "timeout") {
+    return false;
+  }
+  if (gate.status === "timeout") return true;
+  return !reportsUnavailableTool(gate.exitCode, gate.outputTail);
+}
+function verificationLoopHasConcreteFailure(lastIteration) {
+  return [lastIteration?.build, lastIteration?.lint, lastIteration?.tests].some(
+    (gate) => isConcreteGateFailure(gate)
+  );
+}
+function verificationFindingHasConcreteFailure(result) {
+  return result.verification?.findings?.some(
+    (finding) => finding.severity === "error" && !reportsUnavailableTool(finding.exitCode, finding.outputTail, finding.unavailableReason)
+  ) === true;
+}
+function concreteExecutedFailureChannels(result, options) {
+  const channels = /* @__PURE__ */ new Set();
+  if (options.directTestFailure === true) channels.add("test");
+  if (isConcreteGateFailure(options.lastIteration?.build)) channels.add("build");
+  if (isConcreteGateFailure(options.lastIteration?.lint)) channels.add("lint");
+  if (isConcreteGateFailure(options.lastIteration?.tests)) channels.add("test");
+  for (const finding of result.verification?.findings ?? []) {
+    if (finding.severity === "error" && !reportsUnavailableTool(finding.exitCode, finding.outputTail, finding.unavailableReason)) {
+      channels.add(
+        finding.kind === "build" || finding.kind === "lint" || finding.kind === "test" ? finding.kind : "other"
+      );
+    }
+  }
+  return [...channels];
+}
+function hasConcreteExecutedGateFailure(result, options) {
+  return options.directTestFailure === true || verificationFindingHasConcreteFailure(result) || verificationLoopHasConcreteFailure(options.lastIteration);
+}
+
+// src/core/judge/judge-types-core.ts
+var directRunnerTrustLogger = createLogger("judge-types-core");
+function hasVariantFileChangeEvidence(result) {
+  return Boolean(
+    (result.filesChanged ?? 0) > 0 || (result.linesAdded ?? 0) > 0 || (result.linesRemoved ?? 0) > 0 || (result.gitMetrics?.filesChanged ?? 0) > 0 || (result.gitMetrics?.linesAdded ?? 0) > 0 || (result.gitMetrics?.linesDeleted ?? 0) > 0 || (result.worktreeSummary?.filesChanged ?? 0) > 0 || (result.worktreeSummary?.insertions ?? 0) > 0 || (result.worktreeSummary?.deletions ?? 0) > 0 || (result.workspaceEditsApplied ?? 0) > 0
+  );
+}
+function hasIgnoredPlanningArtifactEvidence(result) {
+  const paths = result.ignoredPathEvidence?.paths;
+  if (!Array.isArray(paths) || paths.length === 0) return false;
+  return paths.some(isIgnoredPlanningArtifactPath);
+}
+function hasVariantChangeEvidence(result) {
+  if (hasVariantFileChangeEvidence(result)) return true;
+  if (hasIgnoredPlanningArtifactEvidence(result)) return true;
+  if (result.executionIntent === "analysis" || result.allowEmptyResults === true || result.intentionalNoOp === true) {
+    return false;
+  }
+  return result.partialEdits === true || result.emptyChanges === false;
+}
+function deriveExecutionStatus(result) {
+  if (result.timedOut === true || result.terminationReason === "timeout") {
+    return "timed_out";
+  }
+  if (result.terminationReason === "canceled_early_exit" || result.terminationReason === "canceled_budget" || result.terminationReason === "canceled_user") {
+    return "canceled";
+  }
+  if (result.terminationReason === "failed_crash") {
+    return "crashed";
+  }
+  if (result.terminationReason === "failed_error") {
+    return "failed";
+  }
+  if (result.terminationReason === "completed") {
+    return "completed";
+  }
+  if (result.success === false) {
+    return "failed";
+  }
+  return "completed";
+}
+function deriveDeliveryStatus(score, hasChanges) {
+  if (score >= 95) return "complete";
+  if (score >= 60) return "substantial";
+  if (score > 0 || hasChanges) return "partial";
+  return "none";
+}
+function gateStatusFromArtifact(status, exitCode) {
+  if (status === "error") return "failed";
+  return RECORDED_GATE_STATUS[verdictStatus(status === "not_run" ? void 0 : status, exitCode)];
+}
+var RECORDED_GATE_STATUS = {
+  passed: "passed",
+  failed: "failed",
+  timeout: "failed",
+  unavailable: "not_run",
+  not_run: "not_run"
+};
+function verdictStatus(status, exitCode) {
+  if (status === "passed" || status === "failed" || status === "timeout") return status;
+  if (status === "unavailable" || status === "not_run") return status;
+  if (status === "skipped") return "not_run";
+  const realExit = typeof exitCode === "number" && exitCode !== 0 && !isToolNotFoundExit(exitCode);
+  if (status === "error") return realExit ? "failed" : "unavailable";
+  return typeof exitCode !== "number" ? "not_run" : exitCode === 0 ? "passed" : "failed";
+}
+function gateAttempt(status, evidence, unavailableReason) {
+  return {
+    status,
+    ...status === "unavailable" && unavailableReason ? { unavailableReason } : {},
+    ...evidence?.command ? { command: evidence.command } : {},
+    ...typeof evidence?.exitCode === "number" ? { exitCode: evidence.exitCode } : {}
+  };
+}
+function findingGateAttempt(result, kind) {
+  const finding = result.verification?.findings?.find((entry) => entry.kind === kind);
+  if (!finding) return { status: "not_run" };
+  const status = isUnavailableVerificationFinding(finding) ? "unavailable" : verdictStatus(void 0, finding.exitCode);
+  return gateAttempt(status, finding, finding.unavailableReason);
+}
+function testGateVerdict(result, last, rawTouchedFailureStands) {
+  const reason = result.verification?.findings?.find(
+    (entry) => entry.kind === "test"
+  )?.unavailableReason;
+  const executed = result.testsExecuted;
+  const raw = executed?.skipReason === "verification-unavailable" ? gateAttempt("unavailable", executed, reason) : executed?.scope === "none" ? gateAttempt("not_run", executed, reason) : gateAttempt(verdictStatus(result.testStatus, executed?.exitCode), executed, reason);
+  const ran = (gate) => gate.status !== "unavailable" && gate.status !== "not_run";
+  if (rawTouchedFailureStands && ran(raw) && raw.status !== "passed" || !last?.tests) return raw;
+  const loop = gateAttempt(
+    verdictStatus(last.tests.status, last.tests.exitCode),
+    last.tests,
+    reason
+  );
+  if (ran(loop)) return loop;
+  return ran(raw) || raw.status === "unavailable" && loop.status === "not_run" ? raw : loop;
+}
+function gateSubject(channel, gate) {
+  if (!gate.command) return channel;
+  const lines = gate.command.split(/\s*\n\s*/).filter(Boolean);
+  const label = channel === "build" && lines.length > 0 && lines.every((line) => describeVerificationCommand(line).kind === "typecheck") ? "typecheck" : channel;
+  return `${label}: ${lines.join("; ")}`;
+}
+function describeGate(channel, gate) {
+  const subject = gateSubject(channel, gate);
+  const exit = gate.exitCode !== void 0 ? ` (exit ${gate.exitCode})` : "";
+  if (gate.status === "timeout") return `${subject} timed out${exit}`;
+  if (gate.status === "failed") return `${subject} failed${exit}`;
+  return `${subject} unavailable${gate.unavailableReason ? ` (${gate.unavailableReason})` : ""}`;
+}
+function describePassedGate(channel, gate) {
+  const subject = gateSubject(channel, gate);
+  return `${subject} exited ${gate.exitCode ?? 0}`;
+}
+function verificationReason(status, gates, context) {
+  if (status === "passed") return void 0;
+  if (context.failedBeforeDelivery) return "execution failed before verification";
+  if (context.baselineRegression) return "new failures compared with the base commit";
+  const deciding = status === "not_run" ? ["unavailable"] : ["failed", "timeout"];
+  for (const channel of ["test", "build", "lint"]) {
+    if (!deciding.includes(gates[channel].status)) continue;
+    const line = describeGate(channel, gates[channel]);
+    return status === "baseline_clean" ? `${line}; the base commit fails the same way` : line;
+  }
+  if (status === "baseline_clean") return "the same failures are present on the base commit";
+  if (status === "not_run") {
+    const ranChannel = ["test", "build", "lint"].find(
+      (channel) => gates[channel].status === "passed"
+    );
+    if (ranChannel) {
+      return `${describePassedGate(ranChannel, gates[ranChannel])} but nothing corroborated that it ran, so it is not counted as verification`;
+    }
+  }
+  return status === "failed" ? "verification reported a failure" : "no verification ran";
+}
+function normalizeTestScope(scope) {
+  return scope === "targeted" ? "touched" : scope ?? "none";
+}
+function hasVerifiedTouchedTestFailure(result) {
+  if (normalizeTestScope(result.testsExecuted?.scope) !== "touched") return false;
+  if (result.testStatus !== "failed" && result.testStatus !== "error" && result.testStatus !== "timeout") {
+    return false;
+  }
+  if (result.testStatus === "timeout") return true;
+  return typeof result.testsExecuted?.exitCode === "number" ? result.testsExecuted.exitCode !== 0 : true;
+}
+function repairOutcomeCanSupersedeRawTouchedFailure(result) {
+  if (result.repairOutcome?.attempted !== true || result.repairOutcome.passed !== true) {
+    return false;
+  }
+  return result.repairOutcome.classification === "mechanical" || result.repairOutcome.classification === "substantive_in_scope" || result.repairOutcome.classification === "scope_expanded";
+}
+function deriveVerificationStatus(result) {
+  const executionStatus = deriveExecutionStatus(result);
+  const hasChanges = hasVariantChangeEvidence(result);
+  const failedBeforeDelivery = result.success === false && !hasChanges && (executionStatus === "crashed" || executionStatus === "failed" || executionStatus === "timed_out" || executionStatus === "canceled");
+  const last = latestVerificationIteration(result.verificationLoop);
+  const loopPassed = result.verificationLoop?.enabled ? result.verificationLoop.passed : null;
+  const loopPromotable = result.verificationLoop?.enabled ? result.verificationLoop.bestIterationPromotable ?? result.verificationLoop.passed ?? false : null;
+  const verificationPassed = loopPassed !== null ? loopPassed : result.verification?.passed ?? null;
+  const testsExecuted = result.testsExecuted;
+  const testsScope = testsExecuted?.scope;
+  const rawTestStatus = result.testStatus;
+  const corroboratedTestExecutionEvidence = Boolean(
+    testsExecuted && testsScope !== "none" && hasRecordedTestExecutionEvidence({
+      command: testsExecuted.command,
+      filesTested: testsExecuted.filesTested,
+      totalTests: result.testMetrics?.totalTests ?? 0,
+      exitCode: testsExecuted.exitCode
+    })
+  );
+  const directRunnerCleanPass = isDirectRunnerCleanPassRecord({
+    scope: testsScope,
+    command: testsExecuted?.command,
+    commands: testsExecuted?.commands,
+    exitCode: testsExecuted?.exitCode,
+    testStatus: rawTestStatus,
+    skipReason: testsExecuted?.skipReason,
+    outputTail: testsExecuted?.outputTail
+  });
+  if (directRunnerCleanPass && !corroboratedTestExecutionEvidence) {
+    directRunnerTrustLogger.debug("trusted direct-runner exit 0 pass without count corroboration", {
+      command: testsExecuted?.command
+    });
+  }
+  const hasTrustedTestExecutionEvidence = corroboratedTestExecutionEvidence || directRunnerCleanPass;
+  const unrepairedTouchedTestFailure = hasVerifiedTouchedTestFailure(result) && !repairOutcomeCanSupersedeRawTouchedFailure(result);
+  const rawTestExitFailure = typeof testsExecuted?.exitCode === "number" && testsExecuted.exitCode !== 0;
+  const rawTestCountFailure = (result.testMetrics?.failedTests ?? 0) > 0;
+  const rawTestStatusFailure = rawTestStatus === "failed" || rawTestStatus === "error" || rawTestStatus === "timeout";
+  const verificationLoopTestsPassed = result.verificationLoop?.enabled === true && result.verificationLoop.passed === true && last?.tests !== void 0 && last.tests.status !== "unavailable" && last.tests.status !== "skipped" && last.tests.exitCode === 0;
+  const staleRawTestArtifactFailure = !rawTestStatusFailure && verificationLoopTestsPassed && (rawTestExitFailure || rawTestCountFailure);
+  const unrepairedRawTestFailure = (rawTestStatusFailure || rawTestExitFailure || rawTestCountFailure) && !staleRawTestArtifactFailure && (!hasUnavailableTestVerificationEvidence(result) || hasRecordedExecutedTestFailure(result)) && !repairOutcomeCanSupersedeRawTouchedFailure(result);
+  const trustedTestStatus = unrepairedTouchedTestFailure ? "failed" : last?.tests !== void 0 ? last.tests.status === "unavailable" || last.tests.status === "skipped" ? null : last.tests.exitCode === 0 ? "passed" : "failed" : hasTrustedTestExecutionEvidence ? hasUnavailableTestVerificationEvidence(result) ? null : rawTestStatus === "passed" ? "passed" : rawTestStatus === "failed" || rawTestStatus === "error" || rawTestStatus === "timeout" ? "failed" : typeof testsExecuted?.exitCode === "number" ? testsExecuted.exitCode === 0 ? "passed" : "failed" : null : null;
+  const buildGate = last?.build ? gateAttempt(verdictStatus(last.build.status, last.build.exitCode), last.build, void 0) : findingGateAttempt(result, "build");
+  const lintGate = last?.lint ? gateAttempt(verdictStatus(last.lint.status, last.lint.exitCode), last.lint, void 0) : findingGateAttempt(result, "lint");
+  const buildStatus = last?.build ? gateStatusFromArtifact(last.build.status, last.build.exitCode) : RECORDED_GATE_STATUS[buildGate.status];
+  const lintStatus = last?.lint ? gateStatusFromArtifact(last.lint.status, last.lint.exitCode) : RECORDED_GATE_STATUS[lintGate.status];
+  const testStatus = unrepairedTouchedTestFailure || unrepairedRawTestFailure ? "failed" : last?.tests !== void 0 ? last.tests.status === "unavailable" || last.tests.status === "skipped" ? "not_run" : gateStatusFromArtifact(last.tests.status, last.tests.exitCode) : testsScope === "none" ? "not_run" : trustedTestStatus ?? (verificationPassed === true && result.testsExecuted ? "passed" : "not_run");
+  const baselineRegression = result.baselineComparison?.summary.shouldPenalize === true;
+  const unavailableVerificationGate = hasVetoingUnavailableVerificationGateEvidence(result);
+  const finalLintFailure = lintStatus === "failed" && result.verificationLoop?.enabled !== true;
+  const directTestHasConcreteFailure = hasTrustedTestExecutionEvidence && (trustedTestStatus === "failed" || unrepairedRawTestFailure) && !isToolNotFoundExit(result.testsExecuted?.exitCode);
+  const unavailableVerificationHasExecutedFailure = unavailableVerificationGate && hasConcreteExecutedGateFailure(result, {
+    directTestFailure: directTestHasConcreteFailure,
+    lastIteration: last
+  });
+  const failedChannels = new Set(
+    unavailableVerificationHasExecutedFailure ? concreteExecutedFailureChannels(result, {
+      directTestFailure: directTestHasConcreteFailure,
+      lastIteration: last
+    }) : []
+  );
+  if (trustedTestStatus === "failed" || unrepairedRawTestFailure) failedChannels.add("test");
+  if (buildStatus === "failed") failedChannels.add("build");
+  if (finalLintFailure) failedChannels.add("lint");
+  const failuresExplainedByBase = failedChannels.size > 0 && !failedChannels.has("other") && baselineComparisonProvesCleanForChannels(result.baselineComparison, [
+    ...failedChannels
+  ]);
+  const verificationIncompleteWithoutFailure = verificationPassed === false && result.verificationLoop?.enabled === true && result.verificationLoop.passedBaseline === true && (result.verification?.findings?.length ?? 0) === 0;
+  let status;
+  if (failedBeforeDelivery) {
+    status = "not_run";
+  } else if (baselineRegression) {
+    status = "failed";
+  } else if (unavailableVerificationHasExecutedFailure) {
+    status = failuresExplainedByBase && result.baselineComparison?.summary.comparisonUnavailable !== void 0 ? "baseline_clean" : "failed";
+  } else if (unavailableVerificationGate) {
+    status = "not_run";
+  } else if (trustedTestStatus === "failed" || unrepairedRawTestFailure) {
+    status = failuresExplainedByBase ? "baseline_clean" : "failed";
+  } else if (buildStatus === "failed") {
+    status = failuresExplainedByBase ? "baseline_clean" : "failed";
+  } else if (finalLintFailure) {
+    status = failuresExplainedByBase ? "baseline_clean" : "failed";
+  } else if (verificationPassed === true && testStatus === "passed") {
+    status = "passed";
+  } else if (verificationPassed === true && testStatus === "not_run") {
+    status = "not_run";
+  } else if (verificationPassed === false) {
+    if (result.verificationLoop?.enabled && result.verificationLoop.iterations.length > 0) {
+      status = loopPromotable === true ? "baseline_clean" : "not_run";
+    } else {
+      status = baselineComparisonProvesClean(result.baselineComparison) ? "baseline_clean" : "failed";
+    }
+  } else if (trustedTestStatus === "passed") {
+    status = "passed";
+  } else if ((!result.verificationLoop?.enabled || result.verificationLoop.iterations.length === 0) && baselineComparisonProvesClean(result.baselineComparison)) {
+    status = "baseline_clean";
+  } else {
+    status = "not_run";
+  }
+  const offScopeGateConfig = result.offScopeGateConfig;
+  const gateConfigUnverified = offScopeGateConfig !== void 0 && offScopeGateConfig.paths.length > 0 && isVerificationAccepted(status);
+  if (gateConfigUnverified) status = "not_run";
+  const deterministicGatesPassed = failedBeforeDelivery ? null : baselineRegression ? false : status === "not_run" ? null : status === "baseline_clean" ? null : buildStatus === "failed" ? false : finalLintFailure ? false : trustedTestStatus === "failed" || unrepairedRawTestFailure ? false : verificationPassed !== null && testStatus === "passed" ? verificationIncompleteWithoutFailure ? null : verificationPassed : trustedTestStatus === "passed" ? true : null;
+  const deterministicVerdict = status === "baseline_clean" ? "baseline_clean" : deterministicGatesPassed === true ? "passed" : deterministicGatesPassed === false ? "failed" : status === "not_run" ? "not_run" : "no_data";
+  const testGate = testGateVerdict(result, last, unrepairedTouchedTestFailure);
+  const gates = { build: buildGate, lint: lintGate, test: testGate };
+  for (const gate of failedGatesAlsoFailingOnBase(result.baselineComparison, {
+    buildStatus: gates.build.status,
+    lintStatus: gates.lint.status,
+    testStatus: gates.test.status
+  })) {
+    gates[gate].alsoFailingOnBase = true;
+  }
+  return {
+    status,
+    reason: gateConfigUnverified ? offScopeGateConfig.reason : verificationReason(status, gates, { failedBeforeDelivery, baselineRegression }),
+    gates,
+    deterministicGatesPassed,
+    outcome: deterministicVerdict,
+    buildStatus,
+    buildOutcome: buildStatus,
+    lintStatus,
+    testStatus,
+    testOutcome: testStatus,
+    testsScope
+  };
+}
+function deriveRequirementOutcome(probeValidation) {
+  if (!probeValidation) return void 0;
+  const totalCount = Math.max(0, probeValidation.totalExamples ?? 0);
+  const satisfiedCount = Math.max(0, Math.min(totalCount, probeValidation.matchedExamples ?? 0));
+  let status;
+  if (probeValidation.status === "passed") {
+    status = "satisfied";
+  } else if (probeValidation.status === "not_run" || probeValidation.status === "unavailable") {
+    status = "unknown";
+  } else if (satisfiedCount > 0 && satisfiedCount < totalCount) {
+    status = "partial";
+  } else {
+    status = "unsatisfied";
+  }
+  return {
+    status,
+    source: "probe_validation",
+    satisfiedCount,
+    totalCount
+  };
+}
+function deriveVariantOutcome(result) {
+  const score = Number.isFinite(result.completeness) ? result.completeness : 0;
+  const hasChanges = hasVariantChangeEvidence(result);
+  return {
+    execution: {
+      status: deriveExecutionStatus(result),
+      reason: result.terminationReason,
+      exitCode: result.result?.exitCode
+    },
+    delivery: {
+      status: deriveDeliveryStatus(score, hasChanges),
+      score,
+      hasChanges
+    },
+    requirements: deriveRequirementOutcome(result.probeValidation),
+    verification: deriveVerificationStatus(result)
+  };
+}
+function readVariantVerification(record) {
+  const result = record;
+  const stored = result.outcome?.verification;
+  if (stored?.gates) return stored;
+  const derived = deriveVerificationStatus(result);
+  if (!stored) return derived;
+  const gates = { ...derived.gates };
+  const statusField = { build: "buildStatus", lint: "lintStatus", test: "testStatus" };
+  for (const channel of ["build", "lint", "test"]) {
+    const field = stored[statusField[channel]];
+    if (field === void 0) continue;
+    const recorded = verdictStatus(field);
+    const rebuilt = RECORDED_GATE_STATUS[gates[channel].status];
+    if (rebuilt !== RECORDED_GATE_STATUS[recorded] && rebuilt !== "failed") {
+      gates[channel] = { status: recorded };
+    }
+  }
+  for (const gate of failedGatesAlsoFailingOnBase(result.baselineComparison, {
+    buildStatus: gates.build.status,
+    lintStatus: gates.lint.status,
+    testStatus: gates.test.status
+  })) {
+    gates[gate] = { ...gates[gate], alsoFailingOnBase: true };
+  }
+  return {
+    ...stored,
+    gates,
+    reason: stored.status === derived.status ? derived.reason : stored.reason
+  };
+}
+function hasMeaningfulCompetitionProgress(result) {
+  const outcome = result.outcome ?? deriveVariantOutcome(result);
+  return isVerificationAccepted(outcome.verification.status) || outcome.execution.status === "completed" || outcome.delivery.hasChanges;
+}
+function deriveWinnerSelectionSource(judgeType, result) {
+  const metadata = result?.metadata;
+  const winnerSource = typeof metadata?.audit?.winnerSource === "string" ? metadata.audit.winnerSource : null;
+  const selectionMode = typeof metadata?.winnerSelectionMetadata?.selectionMode === "string" ? metadata.winnerSelectionMetadata.selectionMode : null;
+  const fromRanking = winnerSource === "ranking" || winnerSource === "ranking_first" || selectionMode === "ranking";
+  if (judgeType === "ai") return fromRanking ? "ai-judge-ranking" : "ai-judge";
+  if (judgeType === "multi-lens") return fromRanking ? "multi-lens-ranking" : "multi-lens";
+  return "ai-judge";
+}
+function buildRejudgeResult(winner, decision, judged) {
+  const metadata = judged?.find((variant) => variant.judgeEvaluation)?.judgeEvaluation?.metadata;
+  return {
+    winner,
+    decision,
+    ...metadata?.model ? { model: metadata.model } : {},
+    ...metadata?.reportedModel ? { reportedModel: metadata.reportedModel } : {}
+  };
+}
+
+export {
+  storedComparisonUnavailableChannels,
+  isVerificationAccepted,
+  verificationOutcomesFromGateArtifacts,
+  detectGateRegressions,
+  stableComparisonToBaselineComparison,
+  compareVerificationOutcomeToBaseline,
+  persistingIssuesOnBase,
+  identicalToBaseLabel,
+  markLintIdenticalToBase,
+  trustedLoopBaselineComparison,
+  variantGatesAlsoFailingOnBase,
+  failedGatesAlsoFailingOnBase,
+  createLogger,
+  isIgnoredPlanningArtifactPath,
+  baselineComparisonProvesClean,
+  baselineComparisonProvesCleanForChannels,
+  stableBaselineProvesClean,
+  applyKnownFailureDowngrade,
+  isToolNotFoundExit,
+  isConcreteGateFailure,
+  concreteExecutedFailureChannels,
+  hasConcreteExecutedGateFailure,
+  classifyExitZeroTestMetrics,
+  recordedTestResultPredatesRepair,
+  hasTestExecutionProvenance,
+  normalizeRecordedTestStatus,
+  hasUnrecognizedRecordedTestStatus,
+  hasRecordedTestExecutionEvidence,
+  recordedTestCommands,
+  latestVerificationIteration,
+  hasUnavailableVerificationGateEvidence,
+  hasVetoingUnavailableVerificationGateEvidence,
+  hasUnavailableTestVerificationEvidence,
+  hasVerifiedTouchedTestFailure,
+  repairOutcomeCanSupersedeRawTouchedFailure,
+  deriveVariantOutcome,
+  readVariantVerification,
+  hasMeaningfulCompetitionProgress,
+  deriveWinnerSelectionSource,
+  buildRejudgeResult
+};
+//# sourceMappingURL=chunk-3OPP2OZB.js.map