@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/variant-worker-COB5YTJX.js

@@ -0,0 +1,4517 @@
+#!/usr/bin/env node
+import {
+  ProcessLifecycleManager,
+  createCliBreadcrumb,
+  evaluateExecutionSpec,
+  findGateControllingEdits,
+  findOffScopeConfigEdits,
+  formatGateConfigUnverifiedReason,
+  formatOffScopeConfigEdits
+} from "./chunk-WMWQEFLN.js";
+import {
+  isNativeResearchEnabledFor,
+  scanWebToolEvents
+} from "./chunk-OSK7QWPD.js";
+import {
+  hasValidationArtifactTarget
+} from "./chunk-3PL22IYZ.js";
+import "./chunk-OMX5VL43.js";
+import {
+  classifyTask
+} from "./chunk-JHP7OT6K.js";
+import {
+  isValidationArtifactEntry
+} from "./chunk-GOFVBTMN.js";
+import {
+  WORKER_CLEANUP_BUDGET_MS,
+  estimateTimeoutCompletenessFromScope,
+  parseShortStatSummary,
+  resolveVariantEvaluation
+} from "./chunk-DIKBRRKE.js";
+import {
+  PROVIDER_ACTIVITY_WORKER_EVENT_PREFIX,
+  PROVIDER_OUTPUT_WORKER_EVENT_PREFIX,
+  ResultStreamer
+} from "./chunk-WEW7UFWE.js";
+import "./chunk-QILAQACE.js";
+import {
+  ACTIVE_HANDLES_MARKER_PREFIX,
+  CLEANUP_COMPLETE_MARKER_PREFIX,
+  CLEANUP_START_MARKER_PREFIX,
+  POST_PROVIDER_PHASES_MARKER_PREFIX,
+  RESULT_WRITTEN_MARKER_PREFIX,
+  getOrCaptureVerificationBaseline,
+  withValidationSlot
+} from "./chunk-3C7WBIVK.js";
+import "./chunk-EKLUBDBQ.js";
+import "./chunk-NEQUQHOX.js";
+import "./chunk-DJG5RIOR.js";
+import {
+  presentUntrustedRepairEvidence,
+  renderRepairConstraints,
+  renderUntrustedCommandOutput,
+  renderUntrustedFailingTests
+} from "./chunk-QS5AGRZN.js";
+import {
+  isTestRunProhibited
+} from "./chunk-NMVZ5YES.js";
+import "./chunk-N3Q2JNPV.js";
+import "./chunk-H4HXVWEC.js";
+import "./chunk-BZRLSZNV.js";
+import "./chunk-C7AGUJ5K.js";
+import "./chunk-VLMDM56Q.js";
+import "./chunk-HBZ322WZ.js";
+import {
+  computeProcessReliabilityMetrics,
+  generateBranchName,
+  getVerificationResult,
+  sanitizeVariantResult
+} from "./chunk-DCACX7BV.js";
+import "./chunk-EUWIIDQ7.js";
+import "./chunk-ARARVIZK.js";
+import "./chunk-HHWDTB6S.js";
+import {
+  runDeterministicTestGateWithArtifacts,
+  runLintOnDiffWithArtifacts
+} from "./chunk-JOSK6GEU.js";
+import "./chunk-CFCVYHSW.js";
+import "./chunk-VCGSWN5M.js";
+import "./chunk-6CAU7VBA.js";
+import "./chunk-IYY3HQAD.js";
+import "./chunk-ONYPLIVE.js";
+import "./chunk-PVJBTI7P.js";
+import {
+  runTypecheckWithArtifacts
+} from "./chunk-IWBHRSG7.js";
+import "./chunk-UKMPASIC.js";
+import "./chunk-CTDLERWU.js";
+import "./chunk-LPQ7NZEN.js";
+import "./chunk-TGCVL74Y.js";
+import {
+  applyExactArtifactGoalSuccessGate,
+  isSimpleArtifactGoalSatisfied,
+  parseSimpleArtifactGoal
+} from "./chunk-QXBKIHY7.js";
+import "./chunk-Q3DHEZA5.js";
+import "./chunk-QTOLTG4L.js";
+import "./chunk-7HYBSRPZ.js";
+import "./chunk-L32WD57F.js";
+import "./chunk-6DBMALXL.js";
+import "./chunk-MKASIKWZ.js";
+import "./chunk-UDNNAQN5.js";
+import "./chunk-GIJWHUWF.js";
+import "./chunk-HKO45NLZ.js";
+import {
+  extractChangedFilesMeta
+} from "./chunk-QTCLJHLZ.js";
+import "./chunk-SU6UFUQY.js";
+import "./chunk-FSA5BPFI.js";
+import {
+  parsePromptSpec
+} from "./chunk-INJ3SS6A.js";
+import "./chunk-LDJCKAJP.js";
+import "./chunk-3LOY6YZI.js";
+import "./chunk-HS3SY6HN.js";
+import "./chunk-ENYRCL43.js";
+import "./chunk-D37WY7SH.js";
+import "./chunk-Z7CDQNH3.js";
+import "./chunk-PRDHI2L5.js";
+import "./chunk-URMSZXAD.js";
+import "./chunk-JVHGMURQ.js";
+import "./chunk-2YRG3LHZ.js";
+import "./chunk-JYXS47FQ.js";
+import "./chunk-B7PYTV72.js";
+import "./chunk-4QKP6I4C.js";
+import "./chunk-GWHGTG37.js";
+import {
+  FIELD_DISPLAY_NAMES,
+  generateSpecQualitySignals
+} from "./chunk-UAPHFJPN.js";
+import "./chunk-GI5M67YA.js";
+import "./chunk-XON4ZCYX.js";
+import "./chunk-PPHXX4W7.js";
+import "./chunk-5AW4RMNG.js";
+import {
+  ExitCodeError
+} from "./chunk-Y4ZDDHB6.js";
+import "./chunk-BIUV23HH.js";
+import "./chunk-RI4EX2QE.js";
+import "./chunk-ETA2K4KI.js";
+import "./chunk-CRPRVNQ4.js";
+import "./chunk-W4BAIQ6L.js";
+import "./chunk-4UMRUFBD.js";
+import "./chunk-3M57DADF.js";
+import "./chunk-HT5OCGKN.js";
+import "./chunk-FUUVZZUB.js";
+import "./chunk-32IYXIE5.js";
+import "./chunk-7RMARDVH.js";
+import "./chunk-HXIIEMGF.js";
+import {
+  stageCommitEligibleChanges
+} from "./chunk-ZMLOC3DW.js";
+import "./chunk-FIEUSGNJ.js";
+import "./chunk-WEIUS5NT.js";
+import "./chunk-KQYQOXMS.js";
+import "./chunk-S47ISY27.js";
+import "./chunk-U424MJLC.js";
+import "./chunk-YKMXFVK7.js";
+import "./chunk-O6ZQUVTR.js";
+import "./chunk-RCYEJSD5.js";
+import "./chunk-FAWJTC34.js";
+import "./chunk-UBVRHGAZ.js";
+import "./chunk-5HDP7XZG.js";
+import "./chunk-H3ISZJMJ.js";
+import "./chunk-ATKEKM3E.js";
+import "./chunk-S6I4KISU.js";
+import "./chunk-EJIWTPSZ.js";
+import "./chunk-MYLH2S4G.js";
+import "./chunk-3P5IN5E7.js";
+import "./chunk-2Y2IIHPI.js";
+import "./chunk-WEI3ZDZH.js";
+import "./chunk-H6MJGKAW.js";
+import "./chunk-67YRJPJO.js";
+import {
+  setProcessLifecycleManager
+} from "./chunk-633XZ7UF.js";
+import "./chunk-SF6YK3JI.js";
+import "./chunk-JBBB2Y47.js";
+import "./chunk-WJAL4JL3.js";
+import "./chunk-RBKLOUXA.js";
+import "./chunk-4EBSXZ73.js";
+import "./chunk-CSOPSYDY.js";
+import "./chunk-VMFZEVVX.js";
+import "./chunk-U5KS22IN.js";
+import "./chunk-UUUDKV7N.js";
+import {
+  TelemetryLogger
+} from "./chunk-PFCXFO7A.js";
+import "./chunk-SDPIFNLD.js";
+import "./chunk-GO6DRECI.js";
+import "./chunk-XIBVFMLQ.js";
+import "./chunk-QWMQ74KD.js";
+import "./chunk-GAFJEYLK.js";
+import "./chunk-YKC75XK4.js";
+import "./chunk-T7E5JS6N.js";
+import "./chunk-ZJB6SQPA.js";
+import "./chunk-GZK62I3N.js";
+import {
+  signalCoordinator
+} from "./chunk-GC4CRMTS.js";
+import "./chunk-P7CQGPLS.js";
+import "./chunk-C3DH3NCY.js";
+import "./chunk-IVZEONFC.js";
+import "./chunk-XTXYIISX.js";
+import "./chunk-MEMSY6VY.js";
+import "./chunk-VBNCKCCI.js";
+import "./chunk-33IGPPUI.js";
+import "./chunk-UPHU64NB.js";
+import "./chunk-JLS65NUQ.js";
+import "./chunk-FRBPKBFE.js";
+import "./chunk-BAWJNMWF.js";
+import "./chunk-LX4F24ZH.js";
+import "./chunk-BBPIILO2.js";
+import "./chunk-2NMNFUQA.js";
+import "./chunk-I7SCBHJN.js";
+import {
+  formatVariantIdentifier
+} from "./chunk-TGXXYDL4.js";
+import "./chunk-D2M2Y5ID.js";
+import "./chunk-UJP3XM54.js";
+import "./chunk-MULMXX4V.js";
+import {
+  parseGitWorktreeBranches
+} from "./chunk-UTDEOPKV.js";
+import "./chunk-RFDVSI4N.js";
+import "./chunk-M4BUEXXF.js";
+import "./chunk-ZH4G3FU5.js";
+import "./chunk-726G6WDL.js";
+import {
+  captureWorktreeDiff,
+  normalizeWorktreeDiff
+} from "./chunk-EP22ZMFO.js";
+import {
+  getGitChangeSummary
+} from "./chunk-5UBIFVRD.js";
+import "./chunk-O7FE75QZ.js";
+import "./chunk-Q64IR2Z2.js";
+import "./chunk-YVCMDVBB.js";
+import "./chunk-7HPCIOMA.js";
+import {
+  parseJsonWithContext
+} from "./chunk-P6SSWAKY.js";
+import "./chunk-ETAD4NKD.js";
+import "./chunk-XQPEWJPI.js";
+import "./chunk-7YAOUUKK.js";
+import {
+  analyzeRepairScope,
+  buildRepairDiffSnapshot,
+  resolveRepairArtifactPolicy
+} from "./chunk-SKTFRFQ7.js";
+import "./chunk-O5X6BKAO.js";
+import "./chunk-R2CKS6WT.js";
+import {
+  applyKnownFailureDowngrade,
+  compareVerificationOutcomeToBaseline,
+  createLogger,
+  deriveVariantOutcome,
+  detectGateRegressions,
+  hasUnavailableVerificationGateEvidence,
+  hasVerifiedTouchedTestFailure,
+  latestVerificationIteration,
+  markLintIdenticalToBase,
+  persistingIssuesOnBase,
+  repairOutcomeCanSupersedeRawTouchedFailure,
+  stableBaselineProvesClean,
+  stableComparisonToBaselineComparison,
+  trustedLoopBaselineComparison,
+  verificationOutcomesFromGateArtifacts
+} from "./chunk-3OPP2OZB.js";
+import "./chunk-EPRMH6HO.js";
+import "./chunk-XHOI4V62.js";
+import "./chunk-S2VQCZO4.js";
+import {
+  dominantVerificationStatus
+} from "./chunk-6TBEX4R4.js";
+import "./chunk-PXKERBKX.js";
+import "./chunk-QYQOVOLR.js";
+import "./chunk-QFLBRWCJ.js";
+import "./chunk-AEQWV746.js";
+import "./chunk-SVUNZOPG.js";
+import "./chunk-KUEWV2JH.js";
+import "./chunk-R2TIYG7U.js";
+import "./chunk-5FKHIKTS.js";
+import "./chunk-S2E632FQ.js";
+import "./chunk-XJ2E7YEJ.js";
+import "./chunk-B7YRSULE.js";
+import "./chunk-4U6XK2DG.js";
+import "./chunk-BY6ODHNZ.js";
+import "./chunk-3H4MWYIC.js";
+import "./chunk-DP7FKP6W.js";
+import "./chunk-VIFHYTI5.js";
+import "./chunk-XGU6PBO5.js";
+import "./chunk-F55YABKV.js";
+import {
+  captureCurrentWorkspaceTreeIdentity
+} from "./chunk-YO5BAJ55.js";
+import "./chunk-EVE3OD2W.js";
+import {
+  mkBuildTempDir
+} from "./chunk-D6WTZMZB.js";
+import "./chunk-5EQN56OZ.js";
+import "./chunk-RBBTBCHX.js";
+import "./chunk-4DJL2VXA.js";
+import {
+  channelsFailingIdenticallyOnBase,
+  requiredVerificationControlChannels,
+  resolveVerificationChannelScope,
+  selectScopedTestCommands
+} from "./chunk-AHU3FKPA.js";
+import "./chunk-TUQMMFEQ.js";
+import {
+  describeVerificationCommand
+} from "./chunk-EPAMVGI3.js";
+import "./chunk-6CB3KJRY.js";
+import "./chunk-L2S235CU.js";
+import "./chunk-D4VJFCGZ.js";
+import {
+  PROJECT_SOURCE_EXTENSIONS,
+  isProjectSourcePath
+} from "./chunk-RPIMAMV7.js";
+import "./chunk-ALDTFNZ3.js";
+import "./chunk-QOIASNEJ.js";
+import {
+  resolveVerifyCommandTimeoutMs
+} from "./chunk-2VUEDIUM.js";
+import "./chunk-MJ6WNSIX.js";
+import "./chunk-5KQETTNS.js";
+import "./chunk-J2ICMYDA.js";
+import {
+  truncateToByteLimit
+} from "./chunk-2VLJUXJU.js";
+import "./chunk-PPZESPJT.js";
+import "./chunk-XCOIBNET.js";
+import "./chunk-Y733RB7T.js";
+import "./chunk-H3HGMISG.js";
+import "./chunk-FAZBRHGG.js";
+import "./chunk-CJBSZX3F.js";
+import {
+  initializeLabModeFromEnv
+} from "./chunk-C3KCMAJP.js";
+import "./chunk-FKCG7K6H.js";
+import "./chunk-AJN5Y5YZ.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import "./chunk-HEP3ILP4.js";
+import "./chunk-BQJOGAWT.js";
+import "./chunk-WV3KQDPE.js";
+import {
+  isSensitiveKey,
+  sanitizeSynthesisArtifactForPersistence,
+  sanitizeSynthesisStringForPersistence
+} from "./chunk-VSWC5ZXI.js";
+import "./chunk-XV7NZL4B.js";
+import "./chunk-KKQKWAMF.js";
+import "./chunk-RWQQIKIC.js";
+import "./chunk-GVJGSSKM.js";
+import "./chunk-QJ6OEH4K.js";
+import "./chunk-BD3PGW6A.js";
+import "./chunk-43OKHTW4.js";
+import "./chunk-MNOVBYFU.js";
+import "./chunk-QXBKTJT6.js";
+import "./chunk-4BTDUT2S.js";
+import "./chunk-35J4NE6S.js";
+import "./chunk-RIMARPCF.js";
+import "./chunk-HGFXODKO.js";
+import "./chunk-N5DX4JAK.js";
+import "./chunk-V2TVPO3X.js";
+import {
+  ProviderExecutionError
+} from "./chunk-RRC5BL7B.js";
+import "./chunk-352PCJLK.js";
+import "./chunk-RCP2Y6DQ.js";
+import {
+  HostTimeoutError,
+  VARIANT_WORKER_SIGTERM_SOURCE,
+  classifyHostTermination,
+  createHostTerminationParsedError,
+  hostTerminationMetadataFromUnknown
+} from "./chunk-M6UHOC4I.js";
+import "./chunk-PSTKWHHN.js";
+import "./chunk-KTMW65UX.js";
+import "./chunk-3JKNRYEE.js";
+import "./chunk-MT2WAIR3.js";
+import "./chunk-WGQAXLNA.js";
+import "./chunk-ONHAMBN6.js";
+import "./chunk-XSJTIFUY.js";
+import "./chunk-XWIZ6B5S.js";
+import "./chunk-U4DRS6ZW.js";
+import {
+  DEFAULT_PER_VARIANT_TIMEOUT_MINUTES,
+  DEFAULT_REPAIR_LOOP_ITERATION_TIMEOUT_MS,
+  DEFAULT_REPAIR_LOOP_MAX_ITERATIONS
+} from "./chunk-I56TH7VM.js";
+import {
+  getWorktreeBaseDir
+} from "./chunk-Z5WGNULV.js";
+import "./chunk-O26L6F7F.js";
+import "./chunk-RJ6RSNT6.js";
+import {
+  assertBuildRuntimeReady
+} from "./chunk-ZORW64QH.js";
+import "./chunk-TAJPCXSB.js";
+import "./chunk-56WPYDJH.js";
+import "./chunk-RSYTSBOO.js";
+import "./chunk-STW7OFOA.js";
+import {
+  resolveBuildRoot
+} from "./chunk-CHA2HDE5.js";
+import "./chunk-JNMWYMC6.js";
+import {
+  BUILD_ALLOW_OFF_SCOPE_REPAIR,
+  BUILD_COMPLETION_MODE,
+  BUILD_TELEMETRY_DIR,
+  createExecutionContext,
+  createWarning,
+  emitWarning,
+  getRuntimeEnv,
+  mergeExecutionContextEnvOverrides,
+  readEnv,
+  resolveBuildDirFromContext,
+  resolveCliRepoRoot,
+  setExecutionContext
+} from "./chunk-7VRJHTGZ.js";
+import "./chunk-XDM65LBX.js";
+import {
+  sanitizeError
+} from "./chunk-CPSVQR2I.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/cli/variant-worker.ts
+import { randomBytes } from "crypto";
+import { closeSync, fsyncSync, openSync } from "fs";
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+import { Command } from "commander";
+import { execa as execa3 } from "execa";
+
+// src/core/verification/known-pre-existing-failures.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+var logger = createLogger("KnownPreExistingFailures");
+var MIN_ERROR_FINGERPRINT_LENGTH = 4;
+var EMPTY_REGISTRY = Object.freeze({
+  schemaVersion: 1,
+  generatedAt: "",
+  baseCommit: "",
+  failures: []
+});
+var _cachedRegistry;
+async function loadKnownPreExistingFailures(repoRoot = process.cwd()) {
+  if (_cachedRegistry !== void 0) {
+    return _cachedRegistry;
+  }
+  const registryPath = process.env.BUILD_KNOWN_FAILURES_PATH ?? path.join(repoRoot, ".build-project", "verification", "known-pre-existing-failures.json");
+  let raw;
+  try {
+    raw = await fs.readFile(registryPath, "utf-8");
+  } catch (err) {
+    const isNotFound = err instanceof Error && "code" in err && err.code === "ENOENT";
+    if (!isNotFound) {
+      logger.warn("Failed to read known-pre-existing-failures registry", {
+        registryPath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+    _cachedRegistry = { ...EMPTY_REGISTRY };
+    return _cachedRegistry;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.failures)) {
+      throw new Error("Registry JSON does not match expected shape");
+    }
+    const registry = parsed;
+    const validFailures = registry.failures.filter(isValidKnownFailureEntry);
+    if (validFailures.length !== registry.failures.length) {
+      logger.warn("Ignoring invalid known-pre-existing-failures registry entries", {
+        registryPath,
+        ignoredCount: registry.failures.length - validFailures.length
+      });
+    }
+    _cachedRegistry = {
+      ...registry,
+      failures: validFailures
+    };
+    logger.debug("Loaded known-pre-existing-failures registry", {
+      registryPath,
+      entryCount: _cachedRegistry.failures.length,
+      baseCommit: _cachedRegistry.baseCommit
+    });
+    return _cachedRegistry;
+  } catch (err) {
+    logger.warn("Malformed known-pre-existing-failures registry \u2014 treating as empty", {
+      registryPath,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    _cachedRegistry = { ...EMPTY_REGISTRY };
+    return _cachedRegistry;
+  }
+}
+function isValidKnownFailureEntry(entry) {
+  return normalizeFingerprint(entry.errorFingerprint) !== null;
+}
+function normalizeFingerprint(fingerprint) {
+  const normalized = fingerprint?.trim();
+  if (!normalized || normalized.length < MIN_ERROR_FINGERPRINT_LENGTH) {
+    return null;
+  }
+  return normalized.toLowerCase();
+}
+function detectRuntimeEnvironment() {
+  if (process.env.CLAUDECODE === "1" || process.env.CLAUDE_CODE === "true" || process.env.AI_SDK === "claude-code") {
+    return "claude-code";
+  }
+  if (process.env.CI === "true" || process.env.CI === "1" || process.env.GITHUB_ACTIONS === "true" || process.env.CIRCLECI === "true" || process.env.TRAVIS === "true") {
+    return "ci";
+  }
+  return "local";
+}
+function looksLikeProjectFileToken(token) {
+  const trimmed = token.trim();
+  if (trimmed.length === 0) return false;
+  if (isProjectSourcePath(trimmed)) return true;
+  return (trimmed.includes("/") || trimmed.includes("\\")) && !/\s/.test(trimmed);
+}
+function parseLiveFailure(raw) {
+  const trimmed = raw.trim();
+  for (const separator of [/\s*>\s*/, /::/]) {
+    const match = separator.exec(trimmed);
+    if (!match || match.index <= 0) continue;
+    const head = trimmed.slice(0, match.index).trim();
+    const tail = trimmed.slice(match.index + match[0].length).trim();
+    if (looksLikeProjectFileToken(head) && tail.length > 0) {
+      return { file: head, testPath: tail, raw };
+    }
+  }
+  const goMatch = /^(.+?):(\d+)$/.exec(trimmed);
+  if (goMatch && looksLikeProjectFileToken(goMatch[1] ?? "")) {
+    return { file: (goMatch[1] ?? "").trim(), testPath: trimmed, raw };
+  }
+  return { file: "", testPath: trimmed, raw };
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var VITEST_FAILURE_MARKER_SOURCE = "(?:\\s*(?:FAIL|FAILURES?|FAILED)\\s+)?[^\\n]*\\.(?:test|spec)\\.[jt]sx?\\s*>\\s+";
+var GENERIC_FAILURE_MARKER_SOURCE = "(?:\\s*(?:FAIL|FAILURES?|FAILED)\\s+)?[^\\n\\s]*[\\\\/][^\\n\\s]*(?:::|\\s>\\s)";
+function findNextFailureMarker(output, startIndex) {
+  const rest = output.slice(startIndex + 1);
+  const match = new RegExp(
+    `\\n(?:${VITEST_FAILURE_MARKER_SOURCE}|${GENERIC_FAILURE_MARKER_SOURCE})`,
+    "i"
+  ).exec(rest);
+  return match ? startIndex + 1 + match.index : output.length;
+}
+function hasFailureMarkers(output) {
+  return new RegExp(
+    `(?:^|\\n)(?:${VITEST_FAILURE_MARKER_SOURCE}|${GENERIC_FAILURE_MARKER_SOURCE})`,
+    "i"
+  ).test(output);
+}
+function extractScopedFailureOutput(live, testOutputTail) {
+  const rawNeedle = live.raw.trim();
+  const candidates = [
+    rawNeedle,
+    live.file && live.testPath ? `${live.file} > ${live.testPath}` : "",
+    live.testPath
+  ].filter((candidate) => candidate.length > 0);
+  for (const candidate of candidates) {
+    const markerPattern = new RegExp(
+      `(?:^|\\n)[^\\n]*${escapeRegExp(candidate)}(?:\\s+\\([^\\n)]*\\))?\\s*(?=\\n|$)`,
+      "i"
+    );
+    const marker = markerPattern.exec(testOutputTail);
+    if (!marker || marker.index === void 0) continue;
+    const start = marker.index;
+    const end = findNextFailureMarker(testOutputTail, start);
+    return testOutputTail.slice(start, end);
+  }
+  return null;
+}
+function matchesRegisteredFailure(live, entry, testOutputTail, runtimeEnvironment = detectRuntimeEnvironment()) {
+  if (live.file !== entry.file) {
+    return false;
+  }
+  const normalizedPath = live.testPath.trim();
+  const normalizedName = entry.testName.trim();
+  if (!normalizedPath.startsWith(normalizedName)) {
+    return false;
+  }
+  const fingerprint = normalizeFingerprint(entry.errorFingerprint);
+  if (!fingerprint) {
+    return false;
+  }
+  const scopedOutput = extractScopedFailureOutput(live, testOutputTail);
+  if (!scopedOutput && hasFailureMarkers(testOutputTail)) {
+    return false;
+  }
+  const searchableOutput = scopedOutput ?? testOutputTail;
+  if (!searchableOutput.toLowerCase().includes(fingerprint)) return false;
+  if (entry.environments !== void 0 && entry.environments.length > 0) {
+    if (!entry.environments.includes(runtimeEnvironment)) {
+      return false;
+    }
+  }
+  return true;
+}
+function allFailuresAreRegistered(liveFailures, registry, testOutputTail, runtimeEnvironment = detectRuntimeEnvironment()) {
+  if (liveFailures.length === 0) return true;
+  if (registry.failures.length === 0) return false;
+  for (const raw of liveFailures) {
+    const live = parseLiveFailure(raw);
+    const matched = registry.failures.some(
+      (entry) => matchesRegisteredFailure(live, entry, testOutputTail, runtimeEnvironment)
+    );
+    if (!matched) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/orchestrator/verification/verification-loop.ts
+import { execa as execa2 } from "execa";
+
+// src/core/verification/repair-artifacts.ts
+import { mkdir, readFile as readFile2, rm, writeFile } from "fs/promises";
+import { dirname, join as join2 } from "path";
+import { execa } from "execa";
+var DEFAULT_CONFIG = {
+  modes: ["patch"],
+  patchDir: ".build-project/repair-patches",
+  refNamespace: "refs/build/repair",
+  branchPrefix: "build/repair"
+};
+function sanitizeForPathSegment(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return "unknown";
+  return trimmed.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 200);
+}
+function sanitizeForGitRefSegment(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return "unknown";
+  const safe = trimmed.replace(/[\s~^:?*[\\]+/g, "_").replace(/\.\.+/g, ".").replace(/^\.*/, "").replace(/\/+/g, "/");
+  return (safe || "unknown").slice(0, 200);
+}
+async function generatePatch(worktreePath, baseRef) {
+  const scratch = await mkBuildTempDir("repair-patch");
+  const indexPath = join2(scratch, "index");
+  const env = { ...process.env, GIT_INDEX_FILE: indexPath };
+  try {
+    const readTree = await execa("git", ["read-tree", baseRef], {
+      cwd: worktreePath,
+      env,
+      stdio: "pipe",
+      reject: false
+    });
+    if (readTree.exitCode !== 0) {
+      throw new Error(`Failed to read base tree: ${readTree.stderr}`);
+    }
+    const add = await execa("git", ["add", "-A"], {
+      cwd: worktreePath,
+      env,
+      stdio: "pipe",
+      reject: false
+    });
+    if (add.exitCode !== 0) {
+      throw new Error(`Failed to stage worktree changes: ${add.stderr}`);
+    }
+    const diff = await execa("git", ["diff", "--cached", "--binary", baseRef, "--"], {
+      cwd: worktreePath,
+      env,
+      stdio: "pipe",
+      reject: false,
+      stripFinalNewline: false
+    });
+    if (diff.exitCode !== 0) {
+      throw new Error(`Failed to generate patch: ${diff.stderr}`);
+    }
+    return diff.stdout;
+  } finally {
+    await rm(scratch, { recursive: true, force: true });
+  }
+}
+async function createCommitFromPatch(opts) {
+  const scratch = await mkBuildTempDir("repair");
+  const indexPath = join2(scratch, "index");
+  const env = { ...process.env, GIT_INDEX_FILE: indexPath };
+  const patch = opts.patchContent.endsWith("\n") ? opts.patchContent : `${opts.patchContent}
+`;
+  try {
+    const readTree = await execa("git", ["read-tree", opts.baseRef], {
+      cwd: opts.worktreePath,
+      env,
+      stdio: "pipe",
+      reject: false
+    });
+    if (readTree.exitCode !== 0) {
+      throw new Error(`Failed to read base tree: ${readTree.stderr}`);
+    }
+    const apply = await execa("git", ["apply", "--cached", "-"], {
+      cwd: opts.worktreePath,
+      env,
+      input: patch,
+      stdio: "pipe",
+      reject: false
+    });
+    if (apply.exitCode !== 0) {
+      throw new Error(`Failed to apply patch to temp index: ${apply.stderr}`);
+    }
+    const writeTree = await execa("git", ["write-tree"], {
+      cwd: opts.worktreePath,
+      env,
+      stdio: "pipe",
+      reject: false
+    });
+    if (writeTree.exitCode !== 0) {
+      throw new Error(`Failed to write tree: ${writeTree.stderr}`);
+    }
+    const treeSha = writeTree.stdout.trim();
+    const commitTree = await execa(
+      "git",
+      ["commit-tree", treeSha, "-p", opts.baseRef, "-m", opts.message],
+      { cwd: opts.worktreePath, env, stdio: "pipe", reject: false }
+    );
+    if (commitTree.exitCode !== 0) {
+      throw new Error(`Failed to create commit: ${commitTree.stderr}`);
+    }
+    return commitTree.stdout.trim();
+  } finally {
+    await rm(scratch, { recursive: true, force: true });
+  }
+}
+async function savePatchFile(patchContent, patchDir, taskId, variantId, iteration) {
+  const safeTaskId = sanitizeForPathSegment(taskId);
+  const safeVariantId = sanitizeForPathSegment(variantId);
+  const patchPath = join2(patchDir, safeTaskId, `${safeVariantId}-iteration-${iteration}.patch`);
+  await mkdir(dirname(patchPath), { recursive: true });
+  await writeFile(patchPath, patchContent, "utf-8");
+  return patchPath;
+}
+async function createGitRef(worktreePath, refNamespace, taskId, variantId, iteration, commitSha) {
+  const safeTaskId = sanitizeForGitRefSegment(taskId);
+  const safeVariantId = sanitizeForGitRefSegment(variantId);
+  const refName = `${refNamespace}/${safeTaskId}/${safeVariantId}/${iteration}`;
+  const updateResult = await execa("git", ["update-ref", refName, commitSha], {
+    cwd: worktreePath,
+    stdio: "pipe",
+    reject: false
+  });
+  if (updateResult.exitCode !== 0) {
+    throw new Error(`Failed to create ref: ${updateResult.stderr}`);
+  }
+  return refName;
+}
+async function createBranch(worktreePath, branchPrefix, taskId, variantId, iteration, commitSha) {
+  const flat = (part) => sanitizeForGitRefSegment(part).replace(/\//g, "-");
+  const branchName = `${branchPrefix}/${flat(taskId)}-${flat(variantId)}-${iteration}`;
+  const result = await execa("git", ["branch", "-f", branchName, commitSha], {
+    cwd: worktreePath,
+    stdio: "pipe",
+    reject: false
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to create branch: ${result.stderr}`);
+  }
+  return branchName;
+}
+async function preserveRepairIteration(worktreePath, baseRef, taskId, variantId, iteration, config = {}) {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const results = [];
+  let patchContent = null;
+  let preservedCommitSha = null;
+  for (const mode of cfg.modes) {
+    try {
+      let artifactPath;
+      switch (mode) {
+        case "patch": {
+          patchContent = patchContent ?? await generatePatch(worktreePath, baseRef);
+          artifactPath = await savePatchFile(
+            patchContent,
+            cfg.patchDir,
+            taskId,
+            variantId,
+            iteration.iteration
+          );
+          break;
+        }
+        case "ref": {
+          patchContent = patchContent ?? await generatePatch(worktreePath, baseRef);
+          preservedCommitSha = preservedCommitSha ?? await createCommitFromPatch({
+            worktreePath,
+            baseRef,
+            patchContent,
+            message: `build: preserve repair (${taskId}, ${variantId}, iter ${iteration.iteration})`
+          });
+          artifactPath = await createGitRef(
+            worktreePath,
+            cfg.refNamespace,
+            taskId,
+            variantId,
+            iteration.iteration,
+            preservedCommitSha
+          );
+          break;
+        }
+        case "branch": {
+          patchContent = patchContent ?? await generatePatch(worktreePath, baseRef);
+          preservedCommitSha = preservedCommitSha ?? await createCommitFromPatch({
+            worktreePath,
+            baseRef,
+            patchContent,
+            message: `build: preserve repair (${taskId}, ${variantId}, iter ${iteration.iteration})`
+          });
+          artifactPath = await createBranch(
+            worktreePath,
+            cfg.branchPrefix,
+            taskId,
+            variantId,
+            iteration.iteration,
+            preservedCommitSha
+          );
+          break;
+        }
+      }
+      results.push({
+        artifactPath,
+        mode,
+        success: true
+      });
+    } catch (error) {
+      results.push({
+        artifactPath: "",
+        mode,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return results;
+}
+function findBestIteration(iterations) {
+  if (iterations.length === 0) {
+    return null;
+  }
+  let bestIndex = 0;
+  let bestIteration = iterations[0];
+  for (let i = 1; i < iterations.length; i++) {
+    const current = iterations[i];
+    if (current.passed && !bestIteration.passed) {
+      bestIndex = i;
+      bestIteration = current;
+      continue;
+    }
+    if (current.passed === bestIteration.passed) {
+      if (current.newIssueCount < bestIteration.newIssueCount) {
+        bestIndex = i;
+        bestIteration = current;
+        continue;
+      }
+      if (current.newIssueCount === bestIteration.newIssueCount && current.fixedIssueCount > bestIteration.fixedIssueCount) {
+        bestIndex = i;
+        bestIteration = current;
+      }
+    }
+  }
+  return { index: bestIndex, iteration: bestIteration };
+}
+async function applyPatchFile(worktreePath, patchPath) {
+  const raw = await readFile2(patchPath, "utf-8");
+  if (raw.trim().length === 0) {
+    return { success: true };
+  }
+  const patchContent = raw.endsWith("\n") ? raw : `${raw}
+`;
+  const result = await execa("git", ["apply", "--3way", "-"], {
+    cwd: worktreePath,
+    input: patchContent,
+    stdio: "pipe",
+    reject: false
+  });
+  if (result.exitCode !== 0) {
+    return {
+      success: false,
+      error: `Failed to apply patch: ${result.stderr}`
+    };
+  }
+  return { success: true };
+}
+async function cherryPickFromRef(worktreePath, refName) {
+  const result = await execa("git", ["cherry-pick", "--no-commit", refName], {
+    cwd: worktreePath,
+    stdio: "pipe",
+    reject: false
+  });
+  if (result.exitCode !== 0) {
+    return {
+      success: false,
+      error: `Failed to cherry-pick: ${result.stderr}`
+    };
+  }
+  return { success: true };
+}
+
+// src/orchestrator/verification/repair-diff-inventory.ts
+var EMPTY = { stdout: "" };
+function git(args, cwd) {
+  return execGit(args, { cwd }).catch(() => EMPTY);
+}
+async function getUntrackedFiles(worktreePath) {
+  const result = await git(["ls-files", "-z", "--others", "--exclude-standard"], worktreePath);
+  return result.stdout.split("\0").filter(Boolean);
+}
+function sumNumstat(stdout) {
+  let total = 0;
+  for (const line of stdout.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parts = trimmed.split(/\s+/);
+    if (parts.length < 3) continue;
+    const added = Number.parseInt(parts[0] ?? "0", 10);
+    const deleted = Number.parseInt(parts[1] ?? "0", 10);
+    total += (Number.isFinite(added) ? added : 0) + (Number.isFinite(deleted) ? deleted : 0);
+  }
+  return total;
+}
+async function getChangedFiles(worktreePath, baselineRef) {
+  const [result, untracked] = await Promise.all([
+    git(["diff", "--name-only", "-z", baselineRef, "--"], worktreePath),
+    getUntrackedFiles(worktreePath)
+  ]);
+  const tracked = result.stdout.split("\0").filter(Boolean);
+  return [.../* @__PURE__ */ new Set([...tracked, ...untracked])].sort();
+}
+async function getDiffSize(worktreePath, baselineRef) {
+  const [result, untracked] = await Promise.all([
+    git(["diff", "--numstat", baselineRef, "--"], worktreePath),
+    getUntrackedFiles(worktreePath)
+  ]);
+  const untrackedStats = await Promise.all(
+    untracked.map(
+      (file) => git(["diff", "--no-index", "--numstat", "--", "/dev/null", file], worktreePath)
+    )
+  );
+  return [result, ...untrackedStats].reduce((total, stat) => total + sumNumstat(stat.stdout), 0);
+}
+
+// src/orchestrator/verification/verification-coverage.ts
+function taskIrrelevantGate(channel) {
+  return {
+    status: "skipped",
+    exitCode: 0,
+    command: `${channel} (not task-relevant)`,
+    verificationCoverage: {
+      status: "skipped_not_relevant",
+      reason: "Channel is not relevant to the changed files."
+    },
+    durationMs: 0,
+    outputTail: `Skipped ${channel} gate: not task-relevant to the changed files.`
+  };
+}
+function controlsPassed(gates, controls) {
+  return controls.every(
+    (channel) => gates[channel === "test" ? "tests" : channel]?.status === "passed"
+  );
+}
+function buildHasNoCoveringCommand(gates) {
+  return gates.build.status === "unavailable" && gates.build.verificationCoverage?.status === "skipped_no_command";
+}
+function testsSupersedeUncoveredBuild(gates, checkTestGate) {
+  return checkTestGate && buildHasNoCoveringCommand(gates) && gates.tests?.status === "passed";
+}
+function gatesHavePromotableCoverage(gates, checkTestGate, controls = []) {
+  if (!controlsPassed(gates, controls)) return false;
+  if (gates.build.status === "unavailable" && !testsSupersedeUncoveredBuild(gates, checkTestGate)) {
+    return false;
+  }
+  if (!checkTestGate) return true;
+  if (gates.build.status !== "passed" && gates.build.status !== "skipped") return true;
+  const testStatus = gates.tests?.status;
+  return testStatus === "skipped" && controls.length > 0 || testStatus === "passed" || testStatus === "failed" || testStatus === "timeout" || testStatus === "error";
+}
+function isHardGateStatus(status) {
+  return status === "failed" || status === "timeout" || status === "error";
+}
+function gatesHaveNoHardFailures(gates, checkTestGate) {
+  if (isHardGateStatus(gates.build.status)) return false;
+  if (!checkTestGate) return true;
+  const testStatus = gates.tests?.status;
+  return testStatus === void 0 || !isHardGateStatus(testStatus);
+}
+function hardGateIncomplete(gates, checkTestGate) {
+  const incomplete = (channel) => [channel?.status, ...(channel?.commandResults ?? []).map((r) => r.status)].some(
+    (status) => status === "timeout" || status === "error"
+  );
+  return incomplete(gates.build) || checkTestGate && incomplete(gates.tests);
+}
+function onlyUnavailableChannelsRemain(gates, options) {
+  const statuses = [
+    gates.build.status,
+    ...options.checkTestGate ? [gates.tests?.status] : [],
+    ...options.controls.map((channel) => gates[channel === "test" ? "tests" : channel]?.status)
+  ].filter((status) => status !== void 0);
+  const notPassing = statuses.filter((status) => status !== "passed" && status !== "skipped");
+  return notPassing.length > 0 && notPassing.every((status) => status === "unavailable");
+}
+function iterationPassesBaseline(input) {
+  const { gates, checkTestGate, controls } = input;
+  const provenNewFailures = input.provenNewFailures || checkTestGate && input.comparison.comparableTestTotalRegressed === true;
+  if (hardGateIncomplete(gates, checkTestGate) || !controlsPassed(gates, controls)) return false;
+  const buildPassedOrOutOfScope = gates.build.status === "passed" || checkTestGate && gates.build.status === "skipped" || testsSupersedeUncoveredBuild(gates, checkTestGate);
+  const passedOutright = !provenNewFailures && buildPassedOrOutOfScope && (!checkTestGate || gates.tests?.status === "passed");
+  const identical = input.identicalToBaseChannels ?? [];
+  const hardChannels = (checkTestGate ? ["build", "test"] : ["build"]).filter(
+    (channel) => !identical.includes(channel)
+  );
+  return passedOutright || stableBaselineProvesClean(input.comparison, provenNewFailures, hardChannels);
+}
+
+// src/orchestrator/verification/verification-loop-outcome-iteration.ts
+function toOutcomeIteration(it, baseline) {
+  return {
+    iteration: it.iteration,
+    passed: it.passed,
+    passedBaseline: it.passedBaseline,
+    newIssueCount: it.newIssueCount,
+    fixedIssueCount: it.fixedIssueCount,
+    durationMs: it.durationMs,
+    costUsd: it.costUsd,
+    cumulativeCostUsd: it.cumulativeCostUsd,
+    constraints: it.constraints,
+    build: it.gates.build,
+    lint: it.gates.lint,
+    tests: it.gates.tests,
+    persistingIssues: it.baselineComparison && persistingIssuesOnBase(it.baselineComparison, baseline, it.gates)
+  };
+}
+
+// src/orchestrator/verification/verification-loop.ts
+function channelCommands2(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 [];
+}
+function dominateGateStatus(statuses) {
+  return dominantVerificationStatus(statuses) ?? "unavailable";
+}
+function isUnavailableCoverage(coverage) {
+  return coverage?.status === "skipped_no_command" || coverage?.status === "skipped_tool_unavailable";
+}
+function buildStatusFromArtifact(build) {
+  if (build.ok) return "passed";
+  if (isUnavailableCoverage(build.verificationCoverage)) return "unavailable";
+  if (build.exitCode === 124) return "timeout";
+  return "failed";
+}
+function lintStatusFromArtifact(lint) {
+  if (isUnavailableCoverage(lint.verificationCoverage)) return "unavailable";
+  if (lint.exitCode === 0) return "passed";
+  if (lint.exitCode === 124) return "timeout";
+  return "failed";
+}
+function testStatusFromArtifact(status) {
+  if (status === "passed") return "passed";
+  if (status === "timeout") return "timeout";
+  if (status === "error") return "error";
+  if (status === "unavailable") return "unavailable";
+  if (status === "skipped") return "skipped";
+  return "failed";
+}
+async function detectRemovedExportsInPublicBarrels(worktreePath, baselineRef) {
+  const PUBLIC_BARRELS = /* @__PURE__ */ new Set(["src/cli/index.ts", "src/orchestrator/index.ts"]);
+  const result = await execa2("git", ["diff", "-U0", baselineRef, "--", "src"], {
+    cwd: worktreePath,
+    stdio: "pipe",
+    reject: false
+  });
+  const diff = String(result.stdout ?? "");
+  const removed = [];
+  let currentFile = null;
+  for (const line of diff.split(/\r?\n/)) {
+    if (line.startsWith("diff --git ")) {
+      const match = /^diff --git a\/(.+?) b\/(.+)$/.exec(line);
+      currentFile = match?.[2] ?? null;
+      continue;
+    }
+    if (!currentFile) continue;
+    if (!PUBLIC_BARRELS.has(currentFile)) continue;
+    if (line.startsWith("-export") || line.startsWith("- export")) {
+      removed.push(`${currentFile}: ${line.slice(1).trim()}`);
+    }
+  }
+  return {
+    removedExportLines: removed.length,
+    sample: removed.slice(0, 3).join("\n") || void 0
+  };
+}
+async function runDeterministicGates(worktreePath, baselineRef, timeoutMs, changedFiles = [], budget = "shared", skipTests = false) {
+  return withValidationSlot(
+    `gates:${worktreePath}`,
+    () => runDeterministicGatesUnpaced(
+      worktreePath,
+      baselineRef,
+      timeoutMs,
+      changedFiles,
+      budget,
+      skipTests
+    ),
+    { maxWaitMs: Math.min(5 * 60 * 1e3, Math.max(5e3, timeoutMs)) }
+  );
+}
+async function runDeterministicGatesUnpaced(worktreePath, baselineRef, timeoutMs, changedFiles = [], budget = "shared", skipTests = false) {
+  const MIN_GATE_TIMEOUT_MS = 5e3;
+  const effectiveTimeoutMs = Math.max(MIN_GATE_TIMEOUT_MS, timeoutMs);
+  const scope = resolveVerificationChannelScope(
+    worktreePath,
+    changedFiles
+  );
+  const buildCommands = channelCommands2(scope.build);
+  const lintCommands = channelCommands2(scope.lint);
+  const testCommands = selectScopedTestCommands(scope);
+  const buildStart = Date.now();
+  const buildChannelBudgetMs = budget === "per-channel" ? effectiveTimeoutMs : Math.min(resolveVerifyCommandTimeoutMs(), effectiveTimeoutMs);
+  const buildArtifacts = scope.build.availability === "unavailable" ? {
+    status: "unavailable",
+    exitCode: 127,
+    command: "build (verification unavailable)",
+    durationMs: 0,
+    stdoutTail: "",
+    stderrTail: "",
+    outputTail: "Build verification unavailable: no covering command for changed language.",
+    verificationCoverage: {
+      status: "skipped_no_command",
+      reason: "No covering build/typecheck command for changed language."
+    }
+  } : scope.build.relevant ? await (async () => {
+    if (buildCommands.length > 0) {
+      let remaining = buildChannelBudgetMs;
+      const commandResults = [];
+      for (const command of buildCommands) {
+        if (remaining <= 0) {
+          commandResults.push({
+            command,
+            language: describeVerificationCommand(command).language,
+            status: "timeout",
+            exitCode: 124,
+            durationMs: 0,
+            outputTail: "Build command skipped: channel timeout budget exhausted."
+          });
+          continue;
+        }
+        const cmdStart = Date.now();
+        const build2 = await runTypecheckWithArtifacts(worktreePath, {
+          timeoutMs: remaining,
+          command
+        });
+        const durationMs = Math.max(build2.durationMs ?? 0, Date.now() - cmdStart);
+        remaining = Math.max(0, remaining - durationMs);
+        const status = buildStatusFromArtifact(build2);
+        commandResults.push({
+          command: build2.command,
+          language: build2.language ?? describeVerificationCommand(command).language,
+          status,
+          exitCode: build2.exitCode,
+          durationMs,
+          outputTail: build2.outputTail,
+          stdoutTail: build2.stdoutTail,
+          stderrTail: build2.stderrTail
+        });
+      }
+      const statuses = commandResults.map((r) => r.status);
+      const aggregateStatus = dominateGateStatus(statuses);
+      const representative = commandResults.find((r) => r.status === aggregateStatus) ?? commandResults[0];
+      const totalDuration = commandResults.reduce((sum, r) => sum + (r.durationMs ?? 0), 0);
+      return {
+        status: aggregateStatus,
+        exitCode: representative.exitCode,
+        command: representative.command,
+        durationMs: Math.max(totalDuration, Date.now() - buildStart),
+        stdoutTail: representative.stdoutTail ?? "",
+        stderrTail: representative.stderrTail ?? "",
+        outputTail: representative.outputTail,
+        language: representative.language,
+        verificationCoverage: aggregateStatus === "unavailable" ? {
+          status: "skipped_tool_unavailable",
+          command: representative.command,
+          reason: "One or more scoped build commands were unavailable."
+        } : aggregateStatus === "passed" ? { status: "verified", command: representative.command } : { status: "unverified", command: representative.command },
+        commandResults
+      };
+    }
+    const build = await runTypecheckWithArtifacts(worktreePath, {
+      timeoutMs: buildChannelBudgetMs,
+      ...scope.scoped && scope.build.command ? { command: scope.build.command } : {}
+    });
+    const buildDurationMs = Date.now() - buildStart;
+    const buildStatus = buildStatusFromArtifact(build);
+    return {
+      status: buildStatus,
+      exitCode: build.exitCode,
+      command: build.command,
+      durationMs: Math.max(build.durationMs ?? 0, buildDurationMs),
+      stdoutTail: build.stdoutTail,
+      stderrTail: build.stderrTail,
+      outputTail: build.outputTail,
+      verificationCoverage: build.verificationCoverage,
+      // Carry the SOURCE-tagged language through so the current side parses by the
+      // same (channel, language) the baseline recorded (root invariant). Fall back
+      // to the scoped command's descriptor when the gate did not tag one.
+      language: build.language ?? (scope.build.command ? describeVerificationCommand(scope.build.command).language : void 0)
+    };
+  })() : {
+    // OUT-OF-SCOPE: this channel was intentionally not run for the task scope
+    // (e.g. a Python-only change does not exercise the Node build). This is a
+    // 'skipped' status (deliberately not run), DISTINCT from 'unavailable' (the
+    // tool was relevant but missing/could-not-run). gatesHavePromotableCoverage
+    // allows an out-of-scope 'skipped' build but still rejects an in-scope
+    // 'unavailable' build, so an out-of-scope channel does not block promotion
+    // while a genuinely-missing in-scope tool stays non-promotable (fail-closed).
+    ...taskIrrelevantGate("build"),
+    stdoutTail: "",
+    stderrTail: ""
+  };
+  const remainingMs = budget === "per-channel" ? effectiveTimeoutMs : Math.max(MIN_GATE_TIMEOUT_MS, effectiveTimeoutMs - (Date.now() - buildStart));
+  const lintTimeoutMs = remainingMs;
+  const testTimeoutMs = remainingMs;
+  const runLintChannel = async () => {
+    if (scope.lint.availability === "unavailable") {
+      return {
+        status: "unavailable",
+        exitCode: 127,
+        command: "lint (verification unavailable)",
+        durationMs: 0,
+        outputTail: "Lint verification unavailable: no covering command for changed language.",
+        verificationCoverage: {
+          status: "skipped_no_command",
+          reason: "No covering lint command for changed language."
+        }
+      };
+    }
+    if (!scope.lint.relevant) {
+      return taskIrrelevantGate("lint");
+    }
+    if (lintCommands.length > 0) {
+      let remaining = lintTimeoutMs;
+      const commandResults = [];
+      for (const command of lintCommands) {
+        if (remaining <= 0) {
+          commandResults.push({
+            command,
+            language: describeVerificationCommand(command).language,
+            status: "timeout",
+            exitCode: 124,
+            durationMs: 0,
+            outputTail: "Lint command skipped: channel timeout budget exhausted."
+          });
+          continue;
+        }
+        const lint3 = await runLintOnDiffWithArtifacts(worktreePath, {
+          baseBranch: baselineRef,
+          timeoutMs: remaining,
+          command
+        });
+        remaining = Math.max(0, remaining - (lint3.durationMs ?? 0));
+        commandResults.push({
+          command: lint3.command,
+          language: lint3.language ?? describeVerificationCommand(command).language,
+          status: lintStatusFromArtifact(lint3),
+          exitCode: lint3.exitCode,
+          durationMs: lint3.durationMs,
+          outputTail: lint3.outputTail
+        });
+      }
+      const aggregateStatus = dominateGateStatus(commandResults.map((r) => r.status));
+      const representative = commandResults.find((r) => r.status === aggregateStatus) ?? commandResults[0];
+      return {
+        status: aggregateStatus,
+        exitCode: representative.exitCode,
+        command: representative.command,
+        durationMs: commandResults.reduce((sum, r) => sum + (r.durationMs ?? 0), 0),
+        outputTail: representative.outputTail,
+        language: representative.language,
+        verificationCoverage: aggregateStatus === "unavailable" ? {
+          status: "skipped_tool_unavailable",
+          command: representative.command,
+          reason: "One or more scoped lint commands were unavailable."
+        } : aggregateStatus === "passed" ? { status: "verified", command: representative.command } : { status: "unverified", command: representative.command },
+        commandResults
+      };
+    }
+    const lint2 = await runLintOnDiffWithArtifacts(worktreePath, {
+      baseBranch: baselineRef,
+      timeoutMs: lintTimeoutMs,
+      ...scope.scoped && scope.lint.command ? { command: scope.lint.command } : {}
+    });
+    return {
+      status: lintStatusFromArtifact(lint2),
+      exitCode: lint2.exitCode,
+      command: lint2.command,
+      durationMs: lint2.durationMs,
+      outputTail: lint2.outputTail,
+      verificationCoverage: lint2.verificationCoverage,
+      language: lint2.language ?? (scope.lint.command ? describeVerificationCommand(scope.lint.command).language : void 0)
+    };
+  };
+  const runTestChannel = async () => {
+    if (skipTests) {
+      return {
+        status: "skipped",
+        exitCode: 0,
+        command: "test (prohibited by task)",
+        durationMs: 0,
+        outputTail: "Skipped test gate: the task prohibits running tests.",
+        failingTests: []
+      };
+    }
+    if (scope.test.availability === "unavailable") {
+      return {
+        status: "unavailable",
+        exitCode: 127,
+        command: "test (verification unavailable)",
+        durationMs: 0,
+        outputTail: "Test verification unavailable: no covering command for changed language.",
+        failingTests: []
+      };
+    }
+    if (!scope.test.relevant) {
+      return {
+        // OUT-OF-SCOPE: intentionally not run for this task scope. 'skipped' (not
+        // run on purpose) is distinct from 'unavailable' (relevant tool missing).
+        ...taskIrrelevantGate("test"),
+        failingTests: []
+      };
+    }
+    if (testCommands.length > 0) {
+      let remaining = testTimeoutMs;
+      const commandResults = [];
+      for (const command of testCommands) {
+        if (remaining <= 0) {
+          commandResults.push({
+            command,
+            language: describeVerificationCommand(command).language,
+            status: "timeout",
+            exitCode: 124,
+            durationMs: 0,
+            outputTail: "Test command skipped: channel timeout budget exhausted.",
+            failingTests: []
+          });
+          continue;
+        }
+        const tests3 = await runDeterministicTestGateWithArtifacts(worktreePath, {
+          baseRef: baselineRef,
+          timeoutMs: remaining,
+          command
+        });
+        remaining = Math.max(0, remaining - (tests3.durationMs ?? 0));
+        const status = testStatusFromArtifact(tests3.status);
+        commandResults.push({
+          command: tests3.command,
+          ...tests3.executables?.length ? { executables: tests3.executables } : {},
+          language: tests3.language ?? describeVerificationCommand(command).language,
+          status,
+          exitCode: tests3.exitCode,
+          durationMs: tests3.durationMs,
+          outputTail: tests3.outputTail,
+          failingTests: tests3.failingTests,
+          failingTestIdentities: tests3.failingTestIdentities
+        });
+      }
+      const aggregateStatus = dominateGateStatus(commandResults.map((r) => r.status));
+      const representative = commandResults.find((r) => r.status === aggregateStatus) ?? commandResults[0];
+      const failingTests = Array.from(new Set(commandResults.flatMap((r) => r.failingTests ?? [])));
+      const failingTestIdentities = Array.from(
+        new Set(commandResults.flatMap((r) => r.failingTestIdentities ?? r.failingTests ?? []))
+      );
+      return {
+        status: aggregateStatus,
+        exitCode: representative.exitCode,
+        command: representative.command,
+        durationMs: commandResults.reduce((sum, r) => sum + (r.durationMs ?? 0), 0),
+        outputTail: representative.outputTail,
+        failingTests,
+        failingTestIdentities,
+        language: representative.language,
+        commandResults,
+        ...commandResults.some((result) => result.executables?.length) ? { executables: commandResults.flatMap((result) => result.executables ?? []) } : {}
+      };
+    }
+    const tests2 = await runDeterministicTestGateWithArtifacts(worktreePath, {
+      baseRef: baselineRef,
+      timeoutMs: testTimeoutMs,
+      ...scope.scoped && scope.test.command ? { command: scope.test.command } : {}
+    });
+    return {
+      status: testStatusFromArtifact(tests2.status),
+      exitCode: tests2.exitCode,
+      command: tests2.command,
+      ...tests2.executables?.length ? { executables: tests2.executables } : {},
+      durationMs: tests2.durationMs,
+      outputTail: tests2.outputTail,
+      failingTests: tests2.failingTests,
+      failingTestIdentities: tests2.failingTestIdentities,
+      language: tests2.language ?? (scope.test.command ? describeVerificationCommand(scope.test.command).language : void 0)
+    };
+  };
+  const [lint, tests] = await Promise.all([runLintChannel(), runTestChannel()]);
+  const gates = {
+    build: buildArtifacts,
+    lint: {
+      status: lint.status,
+      exitCode: lint.exitCode,
+      command: lint.command,
+      durationMs: lint.durationMs,
+      outputTail: lint.outputTail,
+      verificationCoverage: lint.verificationCoverage,
+      language: lint.language,
+      ...lint.commandResults ? { commandResults: lint.commandResults } : {}
+    },
+    tests: {
+      verificationCoverage: tests.verificationCoverage,
+      ...tests.executables?.length ? { executables: tests.executables } : {},
+      status: tests.status,
+      exitCode: tests.exitCode,
+      command: tests.command,
+      durationMs: tests.durationMs,
+      outputTail: tests.outputTail,
+      failingTests: tests.failingTests,
+      failingTestIdentities: tests.failingTestIdentities,
+      language: tests.language,
+      ...tests.commandResults ? { commandResults: tests.commandResults } : {}
+    }
+  };
+  const passed = buildArtifacts.status === "passed" && (tests.status === "passed" || tests.status === "skipped");
+  return { passed, gates };
+}
+function buildVerificationFindings(gates, passedBaseline, controls = []) {
+  if (passedBaseline) return [];
+  const findings = [];
+  for (const kind of ["build", "lint"]) {
+    const channel = gates[kind];
+    if (channel && (kind === "build" || controls.includes(kind)) && isHardGateStatus(channel.status)) {
+      findings.push({
+        kind,
+        command: channel.command,
+        exitCode: channel.exitCode,
+        outputTail: channel.outputTail,
+        severity: "error"
+      });
+    }
+  }
+  if (gates.tests && gates.tests.status !== "passed" && gates.tests.status !== "skipped" && gates.tests.status !== "unavailable") {
+    findings.push({
+      kind: "test",
+      command: gates.tests.command,
+      exitCode: gates.tests.exitCode,
+      outputTail: gates.tests.outputTail,
+      failingTests: gates.tests.failingTests,
+      severity: "error"
+    });
+  }
+  return findings;
+}
+async function runDeterministicVerificationOnce(params) {
+  const checkTestGate = params.checkTestGate ?? true;
+  const controls = requiredVerificationControlChannels(params.changedFiles ?? []);
+  const started = Date.now();
+  const gateRun = params.precomputedGates ? {
+    gates: params.precomputedGates,
+    passed: params.precomputedGates.build.status === "passed" && (!checkTestGate || params.precomputedGates.tests?.status === "passed")
+  } : await runDeterministicGates(
+    params.worktreePath,
+    params.baselineRef,
+    params.timeoutMs,
+    params.changedFiles ?? [],
+    params.budget,
+    !checkTestGate
+  );
+  let passedBaseline = gatesHaveNoHardFailures(gateRun.gates, checkTestGate) && controlsPassed(gateRun.gates, controls);
+  let newIssueCount = 0;
+  let fixedIssueCount = 0;
+  let persistingIssues;
+  if (params.baseline) {
+    const comparisonOutcomes = verificationOutcomesFromGateArtifacts(gateRun.gates, {
+      source: "verification-loop",
+      cwd: params.worktreePath
+    });
+    const baselineComparison = compareVerificationOutcomeToBaseline(
+      params.baseline,
+      comparisonOutcomes
+    );
+    const gateExitRegressions = cleanBaselineGateExitRegressions(
+      params.baseline,
+      baselineComparison,
+      comparisonOutcomes,
+      checkTestGate
+    );
+    const hardStructuredNewIssueCount = baselineComparison.delta.build.newIssues.size + (checkTestGate ? baselineComparison.delta.test.newIssues.size : 0);
+    passedBaseline = iterationPassesBaseline({
+      gates: gateRun.gates,
+      checkTestGate,
+      controls,
+      comparison: baselineComparison,
+      provenNewFailures: hardStructuredNewIssueCount > 0 || gateExitRegressions.length > 0,
+      identicalToBaseChannels: channelsFailingIdenticallyOnBase(
+        params.baseline,
+        gateRun.gates,
+        checkTestGate ? ["build", "test"] : ["build"],
+        [params.worktreePath]
+      )
+    });
+    const unparsedGateRegressionCount = gateExitRegressions.filter((kind) => {
+      if (kind === "build") return baselineComparison.delta.build.newIssues.size === 0;
+      return baselineComparison.delta.test.newIssues.size === 0;
+    }).length;
+    newIssueCount = hardStructuredNewIssueCount + unparsedGateRegressionCount;
+    fixedIssueCount = baselineComparison.delta.totalFixedIssues;
+    persistingIssues = persistingIssuesOnBase(baselineComparison, params.baseline, gateRun.gates);
+  }
+  const durationMs = Date.now() - started;
+  const findings = buildVerificationFindings(gateRun.gates, passedBaseline, controls);
+  const promotable = passedBaseline && gatesHavePromotableCoverage(gateRun.gates, checkTestGate, controls);
+  return {
+    verification: {
+      passed: promotable,
+      passedBaseline,
+      findings
+    },
+    verificationLoop: {
+      enabled: true,
+      passed: promotable,
+      passedBaseline,
+      stopReason: passedBaseline ? "single_iteration_no_new_regressions" : "single_iteration_gates_failed",
+      bestIterationIndex: 0,
+      bestIterationPromotable: promotable,
+      iterations: [
+        {
+          iteration: 1,
+          passed: gateRun.passed,
+          passedBaseline,
+          newIssueCount,
+          fixedIssueCount,
+          durationMs,
+          costUsd: 0,
+          cumulativeCostUsd: 0,
+          constraints: {
+            maxFilesTouched: 0,
+            diffSizeCap: 0,
+            apiBreakAllowed: false,
+            violations: []
+          },
+          build: gateRun.gates.build,
+          lint: gateRun.gates.lint,
+          tests: gateRun.gates.tests,
+          persistingIssues,
+          ...params.precomputedGates ? { gateSource: "precomputed" } : {}
+        }
+      ]
+    }
+  };
+}
+function gateVector(gates) {
+  const build = gates.build.status === "passed" ? 1 : 0;
+  const lint = 1;
+  const tests = gates.tests?.status === "passed" ? 1 : 0;
+  return [build, lint, tests];
+}
+function isRegression(prev, next) {
+  const [pb, pl, pt] = gateVector(prev);
+  const [nb, nl, nt] = gateVector(next);
+  if (nb < pb) return true;
+  const prevSum = pb + pl + pt;
+  const nextSum = nb + nl + nt;
+  return nextSum < prevSum;
+}
+function cleanBaselineGateExitRegressions(baseline, comparison, outcomes, checkTestGate) {
+  const regressed = detectGateRegressions(
+    baseline,
+    { build: outcomes.build, tests: checkTestGate ? outcomes.tests : void 0 },
+    comparison.baseline
+  );
+  return [
+    ...regressed.build ? ["build"] : [],
+    ...regressed.test ? ["test"] : []
+  ];
+}
+function buildRepairPrompt(opts) {
+  const { originalPrompt, iteration, gates, constraints, allowedFiles, scopePolicy } = opts;
+  const parts = [];
+  parts.push(originalPrompt.trimEnd());
+  parts.push("\n\n---\n\n");
+  parts.push(
+    `VERIFICATION-DRIVEN REPAIR (iteration ${iteration}): Fix the deterministic gate failures below.`
+  );
+  parts.push(
+    "Stabilization approach:",
+    "- Prioritize high-leverage, low-cost fixes first (e.g., lint/formatting, obvious type errors).",
+    "- Keep the diff cohesive and targeted; preserve the core solution unless a change is clearly required.",
+    "- Only attempt deeper behavioral/test fixes once cheap failures are resolved or if time remains."
+  );
+  parts.push("Make the MINIMUM change set required to improve gate outcomes.");
+  parts.push(
+    `HARD CONSTRAINTS (enforced): maxFilesTouched=${constraints.maxFilesTouched}, diffSizeCap=${constraints.diffSizeCap}, apiBreakAllowed=${constraints.apiBreakAllowed}`
+  );
+  if (constraints.violations.length > 0) {
+    parts.push(
+      `CONSTRAINT VIOLATIONS DETECTED (must be fixed/undone):
+- ${constraints.violations.join("\n- ")}`
+    );
+  }
+  if (allowedFiles.length > 0) {
+    parts.push(`ALLOWED FILES (derived from prompt/gates):
+- ${allowedFiles.join("\n- ")}`);
+    if (scopePolicy === "strict") {
+      parts.push("SCOPE POLICY: strict - do not modify files outside the allowed list.");
+    }
+  }
+  const gateBlock = (label, g) => {
+    return [
+      `
+${label}:`,
+      `Command: ${g.command}`,
+      `Exit Code: ${g.exitCode}`,
+      `Output (tail):
+${renderUntrustedCommandOutput(g.outputTail)}`
+    ].join("\n");
+  };
+  parts.push(
+    gateBlock("BUILD/TYPECHECK", {
+      command: gates.build.command,
+      exitCode: gates.build.exitCode,
+      outputTail: gates.build.outputTail
+    })
+  );
+  if (gates.lint && gates.lint.status !== "passed") {
+    parts.push(
+      gateBlock("LINT", {
+        command: gates.lint.command,
+        exitCode: gates.lint.exitCode,
+        outputTail: gates.lint.outputTail
+      })
+    );
+  }
+  if (gates.tests && gates.tests.status !== "passed" && gates.tests.status !== "skipped" && gates.tests.status !== "unavailable") {
+    const failing = renderUntrustedFailingTests(gates.tests.failingTests);
+    parts.push(
+      `${gateBlock("TESTS", { command: gates.tests.command, exitCode: gates.tests.exitCode, outputTail: gates.tests.outputTail })}
+${failing}`
+    );
+  }
+  parts.push("\nDo not remove public exports unless explicitly allowed.");
+  parts.push("Keep refactors tightly scoped to what is required for correctness.");
+  parts.push(`
+${renderRepairConstraints()}`);
+  return parts.join("\n");
+}
+var GATE_EVIDENCE_EXTRA_EXTENSIONS = ["json", "css", "scss", "md", "ya?ml", "toml", "snap"];
+function buildGateEvidencePathPattern() {
+  const escapeForClass = (ext) => ext.replace(/[+.]/g, "\\$&");
+  const sourceExtensions = [...PROJECT_SOURCE_EXTENSIONS].map(
+    (ext) => escapeForClass(ext.replace(/^\./, ""))
+  );
+  const extensionAlternation = [...sourceExtensions, ...GATE_EVIDENCE_EXTRA_EXTENSIONS].join("|");
+  return new RegExp(
+    `(?:^|[\\s'"([])((?:\\.{1,2}\\/)?(?:[A-Za-z0-9_.@+-]+\\/)*[A-Za-z0-9_.@+-]+\\.(?:${extensionAlternation}))(?:[:(]|$)`,
+    "gm"
+  );
+}
+var GATE_EVIDENCE_PATH_PATTERN = buildGateEvidencePathPattern();
+function extractFilePathsFromText(text) {
+  if (!text) return [];
+  const paths = /* @__PURE__ */ new Set();
+  for (const match of text.matchAll(GATE_EVIDENCE_PATH_PATTERN)) {
+    const filePath = match[1]?.trim();
+    if (filePath) paths.add(filePath.replace(/^\.\//, ""));
+  }
+  return [...paths];
+}
+function collectIssueFiles(issues) {
+  return issues?.toArray?.().flatMap((issue) => issue.file ? [issue.file] : []) ?? [];
+}
+function deriveAllowedFilesFromGateEvidence(gates, comparison) {
+  const files = /* @__PURE__ */ new Set();
+  for (const file of [
+    ...collectIssueFiles(comparison?.delta.build.newIssues),
+    ...collectIssueFiles(comparison?.delta.lint.newIssues),
+    ...collectIssueFiles(comparison?.delta.test.newIssues),
+    ...extractFilePathsFromText(gates.build.outputTail),
+    ...extractFilePathsFromText(gates.build.stderrTail),
+    ...extractFilePathsFromText(gates.build.stdoutTail),
+    ...extractFilePathsFromText(gates.lint?.outputTail),
+    ...extractFilePathsFromText(gates.tests?.outputTail),
+    ...gates.tests?.failingTests.flatMap(extractFilePathsFromText) ?? []
+  ]) {
+    files.add(file);
+  }
+  return [...files].sort();
+}
+function mergeRepairAllowedFiles(promptAllowedFiles, gateDerivedAllowedFiles) {
+  const merged = /* @__PURE__ */ new Set();
+  for (const file of [...promptAllowedFiles, ...gateDerivedAllowedFiles]) {
+    const normalized = file.trim();
+    if (normalized.length > 0) {
+      merged.add(normalized);
+    }
+  }
+  return [...merged].sort();
+}
+function buildScopedRepairPrompt(opts) {
+  const { originalPrompt, iteration, gates, constraints, comparison, allowedFiles, scopePolicy } = opts;
+  const parts = [];
+  parts.push(originalPrompt.trimEnd());
+  parts.push("\n\n---\n\n");
+  parts.push(
+    `BASELINE-AWARE REPAIR (iteration ${iteration}): Fix only the NEW issues introduced by your changes.`
+  );
+  if (allowedFiles.length > 0) {
+    parts.push(`
+ALLOWED FILES (you may only modify these):
+- ${allowedFiles.join("\n- ")}`);
+    if (scopePolicy === "strict") {
+      parts.push(
+        "\nSCOPE POLICY: strict - Do NOT modify files outside the allowed list, even if they have errors."
+      );
+    } else {
+      parts.push(
+        "\nSCOPE POLICY: expand - You may modify dependent files if they have new errors caused by your changes."
+      );
+    }
+  }
+  parts.push("\nStabilization approach:");
+  parts.push("- Focus ONLY on NEW issues listed below - ignore pre-existing issues.");
+  parts.push("- Prioritize high-leverage, low-cost fixes (lint, obvious type errors).");
+  parts.push("- Keep the diff cohesive; preserve your core solution.");
+  parts.push("- Make the MINIMUM change set to resolve new issues.");
+  const newBuild = comparison.delta.build.newIssues.toArray();
+  const newLint = comparison.delta.lint.newIssues.toArray();
+  const newTest = comparison.delta.test.newIssues.toArray();
+  const totalNew = newBuild.length + newLint.length + newTest.length;
+  if (totalNew > 0) {
+    parts.push(`
+=== NEW ISSUES TO FIX (${totalNew} total) ===`);
+    if (newBuild.length > 0) {
+      parts.push(`
+NEW TYPE ERRORS (${newBuild.length}):`);
+      for (const issue of newBuild.slice(0, 20)) {
+        const loc = issue.line ? `:${issue.line}${issue.col ? `:${issue.col}` : ""}` : "";
+        const message = presentUntrustedRepairEvidence(issue.originalMessage ?? "");
+        parts.push(`- ${issue.file}${loc}: ${issue.code} - ${message}`);
+      }
+      if (newBuild.length > 20) {
+        parts.push(`  ... and ${newBuild.length - 20} more`);
+      }
+    }
+    if (newLint.length > 0) {
+      parts.push(`
+NEW LINT ERRORS (${newLint.length}):`);
+      for (const issue of newLint.slice(0, 20)) {
+        const loc = issue.line ? `:${issue.line}${issue.col ? `:${issue.col}` : ""}` : "";
+        parts.push(`- ${issue.file}${loc}: ${issue.code}`);
+      }
+      if (newLint.length > 20) {
+        parts.push(`  ... and ${newLint.length - 20} more`);
+      }
+    }
+    if (newTest.length > 0) {
+      parts.push(`
+NEW TEST FAILURES (${newTest.length}):`);
+      for (const issue of newTest.slice(0, 10)) {
+        parts.push(`- ${issue.file ? `${issue.file}: ` : ""}${issue.code}`);
+      }
+      if (newTest.length > 10) {
+        parts.push(`  ... and ${newTest.length - 10} more`);
+      }
+    }
+  } else {
+    parts.push("\n=== NO NEW ISSUES ===");
+    parts.push("Your changes have not introduced any new issues vs baseline.");
+    parts.push("If gates are still failing, it is due to pre-existing issues (listed below).");
+  }
+  if (!comparison.passed && totalNew === 0) {
+    const gateBlock = (label, g) => [
+      `
+${label}:`,
+      `Status: ${g.status}`,
+      `Command: ${g.command}`,
+      `Exit Code: ${g.exitCode}`,
+      `Output (tail):
+${renderUntrustedCommandOutput(g.outputTail)}`
+    ].join("\n");
+    parts.push("\n=== UNPARSED GATE REGRESSION OUTPUT ===");
+    parts.push(
+      "A clean baseline gate now exits non-zero, but no stable issue identity could be extracted. Fix the gate failure shown below."
+    );
+    if (gates.build.status !== "passed") {
+      parts.push(gateBlock("BUILD/TYPECHECK", gates.build));
+    }
+    if (gates.lint && gates.lint.status !== "passed") {
+      parts.push(gateBlock("LINT", gates.lint));
+    }
+    if (gates.tests && gates.tests.status !== "passed" && gates.tests.status !== "skipped" && gates.tests.status !== "unavailable") {
+      parts.push(gateBlock("TESTS", gates.tests));
+    }
+  }
+  const persistBuild = comparison.delta.build.persistingIssues.size;
+  const persistLint = comparison.delta.lint.persistingIssues.size;
+  const persistTest = comparison.delta.test.persistingIssues.size;
+  const totalPersist = persistBuild + persistLint + persistTest;
+  if (totalPersist > 0) {
+    parts.push(`
+=== PRE-EXISTING ISSUES (${totalPersist} total - DO NOT fix these) ===`);
+    parts.push("These existed before your changes and are NOT your responsibility:");
+    if (persistBuild > 0) parts.push(`- ${persistBuild} type error(s)`);
+    if (persistLint > 0) parts.push(`- ${persistLint} lint error(s)`);
+    if (persistTest > 0) parts.push(`- ${persistTest} test failure(s)`);
+  }
+  parts.push(
+    `
+HARD CONSTRAINTS: maxFilesTouched=${constraints.maxFilesTouched}, diffSizeCap=${constraints.diffSizeCap}`
+  );
+  if (constraints.violations.length > 0) {
+    parts.push(`CONSTRAINT VIOLATIONS:
+- ${constraints.violations.join("\n- ")}`);
+  }
+  parts.push("\nDo not remove public exports unless explicitly allowed.");
+  parts.push(`
+${renderRepairConstraints()}`);
+  return parts.join("\n");
+}
+async function runVerificationDrivenRepairLoop(params) {
+  const {
+    config,
+    worktreePath,
+    baselineRef,
+    originalPrompt,
+    executeRepair,
+    baseline,
+    taskId,
+    variantId
+  } = params;
+  const repairMode = config.repairMode ?? "auto";
+  const scopePolicy = config.scopePolicy ?? "strict";
+  const allowedFiles = config.allowedFiles ?? [];
+  const repairSaveModes = config.repairSaveModes ?? ["patch"];
+  const checkTestGate = config.checkTestGate ?? true;
+  if (!config.enabled || repairMode === "none") {
+    return {
+      verification: { passed: true, passedBaseline: true, findings: [] },
+      verificationLoop: {
+        enabled: false,
+        passed: true,
+        passedBaseline: true,
+        bestIterationIndex: 0,
+        bestIterationPromotable: true,
+        iterations: []
+      }
+    };
+  }
+  const repairBaseRefResult = await execa2("git", ["rev-parse", "HEAD"], {
+    cwd: worktreePath,
+    stdio: "pipe",
+    reject: false
+  });
+  const repairBaseRef = (repairBaseRefResult.exitCode ?? 0) === 0 ? repairBaseRefResult.stdout.trim() : baselineRef;
+  const iterations = [];
+  const controlScopes = /* @__PURE__ */ new Map();
+  const initialCostUsdRaw = Number(params.initialCostUsd ?? 0);
+  const initialCostUsd = Number.isFinite(initialCostUsdRaw) && initialCostUsdRaw > 0 ? initialCostUsdRaw : 0;
+  let cumulativeCostUsd = initialCostUsd;
+  let initialFilesTouched = 0;
+  let initialDiffSize = 0;
+  let stopReason;
+  let bestIterationIndex = 0;
+  const preserved = [];
+  let unverifiedRepairEdits = false;
+  for (let iteration = 1; iteration <= config.maxIterations; iteration++) {
+    const iterStart = Date.now();
+    unverifiedRepairEdits = false;
+    if (iteration === 1) {
+      const [files, diffSize] = await Promise.all([
+        getChangedFiles(worktreePath, baselineRef),
+        getDiffSize(worktreePath, baselineRef)
+      ]);
+      initialFilesTouched = files.length;
+      initialDiffSize = Math.max(1, diffSize);
+    }
+    const maxFilesTouched = initialFilesTouched + 1;
+    const diffSizeCap = initialDiffSize * 2;
+    const constraints = {
+      maxFilesTouched,
+      diffSizeCap,
+      apiBreakAllowed: config.allowApiBreak,
+      violations: []
+    };
+    const [currentFiles, currentDiffSize, removedExports] = await Promise.all([
+      getChangedFiles(worktreePath, baselineRef),
+      getDiffSize(worktreePath, baselineRef),
+      detectRemovedExportsInPublicBarrels(worktreePath, baselineRef)
+    ]);
+    if (currentFiles.length > maxFilesTouched) {
+      constraints.violations.push(
+        `max_files_touched exceeded: ${currentFiles.length} > ${maxFilesTouched} (${currentFiles.slice(0, 8).join(", ")}${currentFiles.length > 8 ? "\u2026" : ""})`
+      );
+    }
+    if (currentDiffSize > diffSizeCap) {
+      constraints.violations.push(`diff_size_cap exceeded: ${currentDiffSize} > ${diffSizeCap}`);
+    }
+    if (!config.allowApiBreak && removedExports.removedExportLines > 0) {
+      constraints.violations.push(
+        `api_break_detection: removed export lines detected (${removedExports.removedExportLines})${removedExports.sample ? `
+${removedExports.sample}` : ""}`
+      );
+    }
+    const timeboxMs = config.iterationTimeoutMs;
+    const timeRemainingMs = Math.max(0, timeboxMs - (Date.now() - iterStart));
+    const gateRun = constraints.violations.length ? {
+      passed: false,
+      gates: {
+        build: {
+          status: "failed",
+          exitCode: 1,
+          command: "constraint-check",
+          durationMs: 0,
+          stdoutTail: "",
+          stderrTail: "",
+          outputTail: `Constraint violations:
+- ${constraints.violations.join("\n- ")}`
+        }
+      }
+    } : await runDeterministicGates(
+      worktreePath,
+      baselineRef,
+      timeRemainingMs,
+      currentFiles,
+      "shared",
+      config.skipTests === true
+    );
+    const controls = requiredVerificationControlChannels(currentFiles);
+    controlScopes.set(gateRun.gates, controls);
+    const passed = gateRun.passed && controlsPassed(gateRun.gates, controls);
+    const durationMs = Date.now() - iterStart;
+    let baselineComparison;
+    let passedBaseline = gatesHaveNoHardFailures(gateRun.gates, checkTestGate) && controlsPassed(gateRun.gates, controls);
+    let newIssueCount = 0;
+    let fixedIssueCount = 0;
+    if (baseline) {
+      const comparisonOutcomes = verificationOutcomesFromGateArtifacts(gateRun.gates, {
+        source: "verification-loop",
+        cwd: worktreePath
+      });
+      baselineComparison = compareVerificationOutcomeToBaseline(baseline, comparisonOutcomes);
+      const gateExitRegressions = cleanBaselineGateExitRegressions(
+        baseline,
+        baselineComparison,
+        comparisonOutcomes,
+        checkTestGate
+      );
+      const hardStructuredNewIssueCount = baselineComparison.delta.build.newIssues.size + (checkTestGate ? baselineComparison.delta.test.newIssues.size : 0);
+      passedBaseline = iterationPassesBaseline({
+        gates: gateRun.gates,
+        checkTestGate,
+        controls,
+        comparison: baselineComparison,
+        provenNewFailures: hardStructuredNewIssueCount > 0 || gateExitRegressions.length > 0,
+        identicalToBaseChannels: channelsFailingIdenticallyOnBase(
+          baseline,
+          gateRun.gates,
+          checkTestGate ? ["build", "test"] : ["build"],
+          [worktreePath]
+        )
+      });
+      const comparisonForCounts = baselineComparison;
+      const unparsedGateRegressionCount = gateExitRegressions.filter((kind) => {
+        if (kind === "build") return comparisonForCounts.delta.build.newIssues.size === 0;
+        return comparisonForCounts.delta.test.newIssues.size === 0;
+      }).length;
+      newIssueCount = hardStructuredNewIssueCount + unparsedGateRegressionCount;
+      fixedIssueCount = baselineComparison.delta.totalFixedIssues;
+    }
+    const record = {
+      iteration,
+      passed,
+      passedBaseline,
+      newIssueCount,
+      fixedIssueCount,
+      durationMs,
+      costUsd: 0,
+      cumulativeCostUsd,
+      constraints,
+      gates: gateRun.gates,
+      baselineComparison
+    };
+    iterations.push(record);
+    if (taskId && variantId && repairSaveModes.length > 0) {
+      try {
+        const info = {
+          iteration,
+          newIssueCount,
+          fixedIssueCount,
+          passed: passedBaseline,
+          durationMs,
+          costUsd: 0
+        };
+        const artifacts = await preserveRepairIteration(
+          worktreePath,
+          repairBaseRef,
+          taskId,
+          variantId,
+          info,
+          { modes: repairSaveModes }
+        );
+        preserved.push({ info, artifacts });
+      } catch {
+      }
+    }
+    if (config.abortIfRegression && iterations.length >= 2) {
+      const prev = iterations[iterations.length - 2];
+      const next = iterations[iterations.length - 1];
+      const hasBaselineRegression = baseline && next.newIssueCount > prev.newIssueCount;
+      const hasGateRegression = isRegression(prev.gates, next.gates);
+      const hasTestRegression = checkTestGate && baseline && next.baselineComparison && prev.baselineComparison && next.baselineComparison.delta.test.newIssues.size > prev.baselineComparison.delta.test.newIssues.size;
+      if (hasBaselineRegression || hasGateRegression || hasTestRegression) {
+        stopReason = "abort_if_regression";
+        break;
+      }
+    }
+    const effectivePassed = repairMode === "strict" ? passed : passedBaseline;
+    if (effectivePassed) {
+      stopReason = passed ? "gates_passed" : "no_new_regressions";
+      break;
+    }
+    if (newIssueCount === 0 && onlyUnavailableChannelsRemain(gateRun.gates, {
+      checkTestGate: checkTestGate || repairMode === "strict",
+      controls
+    })) {
+      stopReason = "verification_unavailable";
+      break;
+    }
+    if (iteration >= config.maxIterations) {
+      stopReason = "max_iterations_reached";
+      break;
+    }
+    if (durationMs > config.iterationTimeoutMs) {
+      stopReason = "iteration_timebox_exceeded";
+      break;
+    }
+    if (baseline && iterations.length >= 2) {
+      const prevRecord = iterations[iterations.length - 2];
+      if (prevRecord.newIssueCount === newIssueCount && newIssueCount > 0) {
+        stopReason = "no_progress";
+        break;
+      }
+    }
+    let prompt;
+    const repairAllowedFiles = mergeRepairAllowedFiles(
+      allowedFiles,
+      deriveAllowedFilesFromGateEvidence(gateRun.gates, baselineComparison)
+    );
+    if (baseline && baselineComparison) {
+      prompt = buildScopedRepairPrompt({
+        originalPrompt,
+        iteration,
+        gates: gateRun.gates,
+        constraints,
+        comparison: baselineComparison,
+        allowedFiles: repairAllowedFiles,
+        scopePolicy
+      });
+    } else {
+      prompt = buildRepairPrompt({
+        originalPrompt,
+        iteration,
+        gates: gateRun.gates,
+        constraints,
+        allowedFiles: repairAllowedFiles,
+        scopePolicy
+      });
+    }
+    unverifiedRepairEdits = true;
+    const repairStart = Date.now();
+    const repairTimeoutMs = Math.max(1, config.iterationTimeoutMs);
+    const repairAbort = new AbortController();
+    let timeoutId;
+    let repairTimedOut = false;
+    const timeoutRepair = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        repairTimedOut = true;
+        repairAbort.abort();
+        reject(
+          new Error(
+            `executeRepair exceeded iteration timeout (${repairTimeoutMs}ms) at iteration ${iteration}`
+          )
+        );
+      }, repairTimeoutMs);
+      timeoutId.unref?.();
+    });
+    const repairPromise = executeRepair(prompt, iteration - 1, repairAbort.signal);
+    let repair;
+    try {
+      repair = await Promise.race([repairPromise, timeoutRepair]);
+    } catch (err) {
+      repairAbort.abort();
+      repairPromise.catch((repairErr) => {
+        if (repairTimedOut && process.env.BUILD_DEBUG_REPAIR_ABORT === "1") {
+          console.warn(
+            `[verification-loop] repair subprocess exited after abort: ${repairErr instanceof Error ? repairErr.message : String(repairErr)}`
+          );
+        }
+      });
+      stopReason = repairTimedOut ? "iteration_timebox_exceeded" : "repair_execution_failed";
+      record.durationMs = Math.max(record.durationMs, Date.now() - iterStart);
+      if (err instanceof Error) {
+        console.warn(`[verification-loop] ${err.message}`);
+      }
+      break;
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
+    const repairDuration = Date.now() - repairStart;
+    cumulativeCostUsd += Math.max(0, repair.costUsd);
+    record.costUsd = Math.max(0, repair.costUsd);
+    record.cumulativeCostUsd = cumulativeCostUsd;
+    record.durationMs = Math.max(record.durationMs, Date.now() - iterStart);
+    if (preserved.length > 0) {
+      const lastPreserved = preserved[preserved.length - 1];
+      if (lastPreserved?.info.iteration === iteration) {
+        lastPreserved.info.costUsd = record.costUsd;
+        lastPreserved.info.durationMs = record.durationMs;
+      }
+    }
+    if (Date.now() - iterStart > config.iterationTimeoutMs || repairDuration > config.iterationTimeoutMs) {
+      stopReason = "iteration_timebox_exceeded";
+      break;
+    }
+  }
+  const lastIteration = iterations.length > 0 ? iterations[iterations.length - 1] : void 0;
+  let effectiveIteration = lastIteration;
+  let finalPassed = false;
+  let finalPassedBaseline = false;
+  const bestChoice = findBestIteration(
+    iterations.map((it) => ({
+      iteration: it.iteration,
+      newIssueCount: it.newIssueCount,
+      fixedIssueCount: it.fixedIssueCount,
+      passed: it.passedBaseline,
+      durationMs: it.durationMs,
+      costUsd: it.costUsd
+    }))
+  );
+  bestIterationIndex = bestChoice?.index ?? 0;
+  let bestIteration = iterations[bestIterationIndex];
+  let bestIterationPromotable = bestIteration !== void 0 && (bestChoice?.iteration.passed ?? false) ? gatesHavePromotableCoverage(
+    bestIteration.gates,
+    checkTestGate,
+    controlScopes.get(bestIteration.gates)
+  ) : false;
+  let artifactSelectionFinding;
+  let restoreFinding;
+  let repairArtifacts;
+  if (taskId && variantId && preserved.length > 0) {
+    let bestIndex = bestIteration ? preserved.findIndex((p) => p.info.iteration === bestIteration?.iteration) : -1;
+    if (bestIndex < 0) {
+      const bestPreserved = findBestIteration(preserved.map((p) => p.info));
+      bestIndex = bestPreserved?.index ?? 0;
+      const fallbackIteration = preserved[bestIndex]?.info;
+      if (fallbackIteration) {
+        const fallbackIndex = iterations.findIndex(
+          (it) => it.iteration === fallbackIteration.iteration
+        );
+        if (fallbackIndex >= 0) {
+          bestIterationIndex = fallbackIndex;
+          const selectedIteration = iterations[fallbackIndex];
+          bestIteration = selectedIteration;
+          bestIterationPromotable = fallbackIteration.passed && selectedIteration !== void 0 && gatesHavePromotableCoverage(
+            selectedIteration.gates,
+            checkTestGate,
+            controlScopes.get(selectedIteration.gates)
+          );
+        }
+        artifactSelectionFinding = {
+          kind: "other",
+          command: "select-best-repair-artifact",
+          exitCode: 0,
+          severity: "warning",
+          outputTail: "Best verification iteration did not have preserved repair artifacts; selected the best preserved iteration instead."
+        };
+      }
+    }
+    const bestIterationInfo = preserved[bestIndex]?.info ?? preserved[0]?.info;
+    const bestArtifacts = preserved[bestIndex]?.artifacts ?? [];
+    const bestArtifactPath = bestArtifacts.find((a) => a.success)?.artifactPath;
+    repairArtifacts = {
+      taskId,
+      variantId,
+      iterations: preserved,
+      bestIterationIndex: bestIndex,
+      bestIteration: bestIterationInfo,
+      bestArtifactPath
+    };
+  }
+  if (repairArtifacts && repairArtifacts.iterations.length > 0 && repairArtifacts.bestIteration.passed && repairArtifacts.bestIterationIndex !== repairArtifacts.iterations.length - 1) {
+    const bestArtifacts = repairArtifacts.iterations[repairArtifacts.bestIterationIndex]?.artifacts ?? [];
+    const lastArtifacts = repairArtifacts.iterations[repairArtifacts.iterations.length - 1]?.artifacts ?? [];
+    const bestPatch = bestArtifacts.find((a) => a.success && a.mode === "patch")?.artifactPath;
+    const bestRef = bestArtifacts.find(
+      (a) => a.success && (a.mode === "ref" || a.mode === "branch")
+    )?.artifactPath;
+    const lastPatch = lastArtifacts.find((a) => a.success && a.mode === "patch")?.artifactPath;
+    const lastRef = lastArtifacts.find(
+      (a) => a.success && (a.mode === "ref" || a.mode === "branch")
+    )?.artifactPath;
+    const resetToBase = async () => {
+      await execa2("git", ["reset", "--hard", repairBaseRef], {
+        cwd: worktreePath,
+        stdio: "pipe",
+        reject: false
+      });
+      await execa2("git", ["clean", "-fd"], {
+        cwd: worktreePath,
+        stdio: "pipe",
+        reject: false
+      });
+    };
+    const applyArtifact = async (patchPath, refName) => {
+      if (patchPath) {
+        const applied = await applyPatchFile(worktreePath, patchPath);
+        return applied.success;
+      }
+      if (refName) {
+        const applied = await cherryPickFromRef(worktreePath, refName);
+        return applied.success;
+      }
+      return false;
+    };
+    try {
+      await resetToBase();
+      const ok = await applyArtifact(bestPatch, bestRef);
+      unverifiedRepairEdits = false;
+      if (ok) {
+        effectiveIteration = bestIteration;
+      } else {
+        await resetToBase();
+        const restoredLast = await applyArtifact(lastPatch, lastRef);
+        if (!restoredLast) {
+          throw new Error("failed to restore best or last repair artifact");
+        }
+        effectiveIteration = lastIteration;
+        bestIterationPromotable = lastIteration?.passedBaseline === true && gatesHavePromotableCoverage(
+          lastIteration.gates,
+          checkTestGate,
+          controlScopes.get(lastIteration.gates)
+        );
+        restoreFinding = {
+          kind: "other",
+          command: "restore-best-repair-artifact",
+          exitCode: 0,
+          severity: "warning",
+          outputTail: "Best repair artifact could not be restored; restored the last iteration artifact instead."
+        };
+      }
+    } catch (restoreError) {
+      effectiveIteration = void 0;
+      bestIterationPromotable = false;
+      stopReason = "artifact_restore_failed";
+      restoreFinding = {
+        kind: "other",
+        command: "restore-best-repair-artifact",
+        exitCode: 1,
+        severity: "error",
+        outputTail: restoreError instanceof Error ? restoreError.message : String(restoreError)
+      };
+    }
+  }
+  if (unverifiedRepairEdits) {
+    bestIterationPromotable = false;
+  }
+  finalPassed = effectiveIteration?.passed ?? false;
+  finalPassedBaseline = effectiveIteration?.passedBaseline ?? false;
+  const findings = effectiveIteration ? buildVerificationFindings(
+    effectiveIteration.gates,
+    effectiveIteration.passedBaseline,
+    controlScopes.get(effectiveIteration.gates)
+  ) : [];
+  return {
+    verification: {
+      passed: finalPassed,
+      passedBaseline: finalPassedBaseline,
+      findings: [
+        ...findings,
+        ...artifactSelectionFinding ? [artifactSelectionFinding] : [],
+        ...restoreFinding ? [restoreFinding] : []
+      ]
+    },
+    verificationLoop: {
+      enabled: true,
+      passed: finalPassed,
+      passedBaseline: finalPassedBaseline,
+      stopReason: stopReason ?? (finalPassedBaseline ? "no_new_regressions" : "gates_failed"),
+      bestIterationIndex,
+      bestIterationPromotable,
+      iterations: iterations.map((it) => toOutcomeIteration(it, baseline))
+    },
+    repairArtifacts
+  };
+}
+
+// src/cli/variant-off-scope-warning.ts
+function attachOffScopeConfigWarning(result, context) {
+  const prior = (result.warnings ?? []).filter((warning2) => warning2.code === "WS-204");
+  if (prior.length > 0) {
+    result.warnings = (result.warnings ?? []).filter((warning2) => warning2.code !== "WS-204");
+    result.warningCount = Math.max(0, (result.warningCount ?? 0) - prior.length);
+  }
+  delete result.offScopeGateConfig;
+  const diff = result.worktreeDiff;
+  const changedPaths = context.changedPaths ?? (typeof diff === "string" && diff.trim().length > 0 ? extractChangedFilesMeta(diff).map((meta) => meta.path) : []);
+  const edits = findOffScopeConfigEdits(changedPaths, context.prompt);
+  if (edits.length === 0) return;
+  const warning = createWarning(
+    "WS-204",
+    {
+      taskId: context.taskId,
+      subsystem: "variant-worker",
+      executionPhase: "validation"
+    },
+    {
+      metadata: {
+        paths: edits.map((edit) => edit.path),
+        summary: formatOffScopeConfigEdits(edits)
+      }
+    }
+  );
+  const gateEdits = findGateControllingEdits(edits);
+  if (gateEdits.length > 0) {
+    result.offScopeGateConfig = {
+      paths: gateEdits.map((edit) => edit.path),
+      reason: formatGateConfigUnverifiedReason(gateEdits)
+    };
+  }
+  result.warnings = [...result.warnings ?? [], warning];
+  result.warningCount = (result.warningCount ?? 0) + 1;
+}
+
+// src/cli/variant-worker-timeout-snapshot.ts
+async function resolveTimeoutSnapshotCommit(commit, baselineRef, resolveParent) {
+  const autoCommitFailed = commit.exitCode !== 0 || Boolean(
+    commit.failed || commit.timedOut || commit.isCanceled || commit.isTerminated || commit.signal
+  );
+  if (!autoCommitFailed && !baselineRef) baselineRef = await resolveParent();
+  return { autoCommitFailed, baselineRef };
+}
+
+// src/cli/variant-worker.ts
+var MIN_ANALYSIS_COMPLETENESS = 60;
+var PARTIAL_GIT_TIMEOUT_MS = 3e3;
+var SIGNAL_CLEANUP_TIMEOUT_MS = WORKER_CLEANUP_BUDGET_MS;
+var SIGNAL_CLEANUP_WRAPPER_TIMEOUT_MS = SIGNAL_CLEANUP_TIMEOUT_MS + 200;
+var POST_PROVIDER_PHASE_WARN_MS = 3e4;
+function elapsedMsSince(startTime) {
+  return Number((process.hrtime.bigint() - startTime) / 1000000n);
+}
+function addPostProviderPhaseDuration(durations, phase, durationMs) {
+  if (!Number.isFinite(durationMs) || durationMs < 0) return;
+  durations[phase] = (durations[phase] ?? 0) + Math.round(durationMs);
+}
+async function measurePostProviderPhase(durations, phase, verbose, run) {
+  const started = process.hrtime.bigint();
+  try {
+    return await run();
+  } finally {
+    const durationMs = Number((process.hrtime.bigint() - started) / 1000000n);
+    addPostProviderPhaseDuration(durations, phase, durationMs);
+    if (verbose && durationMs >= POST_PROVIDER_PHASE_WARN_MS) {
+      console.log(chalk.gray(`   post-provider phase ${phase} took ${durationMs}ms`));
+    }
+  }
+}
+function measurePostProviderPhaseSync(durations, phase, verbose, run) {
+  const started = process.hrtime.bigint();
+  try {
+    return run();
+  } finally {
+    const durationMs = Number((process.hrtime.bigint() - started) / 1000000n);
+    addPostProviderPhaseDuration(durations, phase, durationMs);
+    if (verbose && durationMs >= POST_PROVIDER_PHASE_WARN_MS) {
+      console.log(chalk.gray(`   post-provider phase ${phase} took ${durationMs}ms`));
+    }
+  }
+}
+function buildShutdownAbortReason(signal) {
+  if (signal === "SIGINT") {
+    return new Error("Variant worker received SIGINT");
+  }
+  return new HostTimeoutError("Variant worker received SIGTERM: host time limit reached", {
+    source: VARIANT_WORKER_SIGTERM_SOURCE
+  });
+}
+function shouldDowngradeSuccessfulResultForShutdown(input) {
+  if (!input.shutdownRequested) return false;
+  if (input.shutdownRequestedAtMs === void 0) return true;
+  if (input.executionResultSettledAtMs === void 0) return true;
+  return input.shutdownRequestedAtMs <= input.executionResultSettledAtMs;
+}
+function activeHandleSummary() {
+  const getActiveHandles = process._getActiveHandles;
+  if (typeof getActiveHandles !== "function") return [];
+  return getActiveHandles().map((handle) => {
+    const record = handle;
+    const type = record.constructor?.name ?? typeof handle;
+    let detail;
+    if (typeof record.fd === "number") {
+      detail = `fd=${record.fd}`;
+    } else if (typeof record.path === "string") {
+      detail = record.path;
+    } else if (typeof record.address === "function") {
+      try {
+        const address = record.address();
+        detail = typeof address === "string" ? address : JSON.stringify(address);
+      } catch {
+        detail = void 0;
+      }
+    }
+    return detail ? { type, detail } : { type };
+  });
+}
+function emitWorkerLifecycleMarker(prefix, value) {
+  try {
+    const payload = typeof value === "number" ? String(value) : JSON.stringify(value);
+    process.stdout.write(`${prefix}${payload}
+`);
+  } catch {
+  }
+}
+function createProviderOutputForwarder(enabled) {
+  if (!enabled) {
+    return { close: () => {
+    } };
+  }
+  const resultStreamer = new ResultStreamer();
+  const listener = (event) => {
+    try {
+      process.stdout.write(`${PROVIDER_OUTPUT_WORKER_EVENT_PREFIX}${JSON.stringify(event)}
+`);
+    } catch {
+    }
+  };
+  const activityListener = (event) => {
+    try {
+      process.stdout.write(`${PROVIDER_ACTIVITY_WORKER_EVENT_PREFIX}${JSON.stringify(event)}
+`);
+    } catch {
+    }
+  };
+  resultStreamer.on("providerOutput", listener);
+  resultStreamer.on("providerActivity", activityListener);
+  return {
+    resultStreamer,
+    close: () => {
+      resultStreamer.off("providerOutput", listener);
+      resultStreamer.off("providerActivity", activityListener);
+      resultStreamer.close();
+    }
+  };
+}
+async function tryLoadPackageJsonScripts(repoRoot) {
+  try {
+    const raw = await fs2.readFile(path2.join(repoRoot, "package.json"), "utf-8");
+    const parsed = JSON.parse(raw);
+    const scripts = parsed.scripts && typeof parsed.scripts === "object" ? parsed.scripts : {};
+    return new Set(Object.keys(scripts));
+  } catch {
+    return void 0;
+  }
+}
+function extractOriginalPrompt(fullPrompt) {
+  const parts = fullPrompt.split(/\n\n---\n\n/);
+  const first = parts[0];
+  if (first?.trimStart().startsWith("[SPEC:") && parts.length > 1) {
+    return parts.slice(1).join("\n\n---\n\n").trim();
+  }
+  return (first ?? fullPrompt).trim();
+}
+function toBaselineComparisonResult(comparison) {
+  return {
+    verdict: comparison.verdict,
+    summary: comparison.summary,
+    baselineRef: comparison.baselineRef,
+    tests: {
+      newFailures: comparison.tests.newFailures,
+      fixedIssues: comparison.tests.fixedIssues,
+      persistingIssues: comparison.tests.persistingIssues
+    },
+    types: {
+      newFailures: comparison.types.newFailures,
+      fixedIssues: comparison.types.fixedIssues,
+      persistingIssues: comparison.types.persistingIssues
+    },
+    lint: {
+      newFailures: comparison.lint.newFailures,
+      fixedIssues: comparison.lint.fixedIssues,
+      persistingIssues: comparison.lint.persistingIssues
+    }
+  };
+}
+function shouldTrustVerificationLoopBaseline(result) {
+  const loop = result.verificationLoop;
+  const last = latestVerificationIteration(loop);
+  if (hasVerifiedTouchedTestFailure(result) && !repairOutcomeCanSupersedeRawTouchedFailure(result)) {
+    return false;
+  }
+  return loop?.enabled === true && loop.passed === true && loop.passedBaseline === true && (last?.newIssueCount ?? 0) === 0;
+}
+function isValidationArtifactOnlyPrompt(prompt) {
+  const hasValidationOnlyDirective = /\bvalidation(?:\s+run)?\s+only\b/i.test(prompt);
+  const targetsValidationArtifact = /\bvalidation\s+artifact\b/i.test(prompt) || hasValidationArtifactTarget(prompt);
+  const forbidsOtherFileChanges = /\b(?:do\s+not|don't)\s+modify\s+(?:any\s+)?other\s+files\b/i.test(prompt) || /\bmodify\s+no\s+other\s+files\b/i.test(prompt);
+  return hasValidationOnlyDirective && targetsValidationArtifact && forbidsOtherFileChanges;
+}
+async function isValidationArtifactOnlyDiffSatisfied(input) {
+  if (!input.worktreePath || !isValidationArtifactOnlyPrompt(input.prompt)) return false;
+  try {
+    const summary = await getGitChangeSummary(input.worktreePath, input.baselineRef, true);
+    return summary.changedPaths.length > 0 && summary.changedPaths.every((changedPath) => isValidationArtifactEntry(changedPath));
+  } catch {
+    return false;
+  }
+}
+async function resolveInitialVerificationDisposition(result, runFallbackVerification) {
+  const dispositionOf = (fresh = false) => getVerificationResult({
+    ...result,
+    ...fresh ? { outcome: void 0 } : {},
+    offScopeGateConfig: void 0
+  });
+  const provider = dispositionOf();
+  if (provider.outcome !== "passed" || result.verificationLoop) return provider;
+  await runFallbackVerification();
+  const observed = dispositionOf(true);
+  return observed.outcome === "failed" ? observed : provider;
+}
+function decideRepairAdmission(input) {
+  const baseEvidence = {
+    ...input.initialVerificationOutcome ? { initialVerificationOutcome: input.initialVerificationOutcome } : {},
+    hasMissingFileTargets: input.hasMissingFileTargets,
+    isClarifyingNoOp: input.isClarifyingNoOp,
+    providerExecutionSucceeded: input.providerExecutionSucceeded,
+    hasMaterializedDeliverable: input.hasMaterializedDeliverable,
+    validationArtifactSatisfied: input.validationArtifactSatisfied,
+    filesChanged: input.filesChanged
+  };
+  if (!input.repairLoopEnabled) {
+    return {
+      action: "skip",
+      reason: "skip_disabled",
+      summary: "Repair loop disabled",
+      ...baseEvidence
+    };
+  }
+  if (input.isAnalysisIntent) {
+    return {
+      action: "skip",
+      reason: "skip_analysis_intent",
+      summary: "Skipped repair loop for analysis intent",
+      ...baseEvidence
+    };
+  }
+  if (!input.hasRetainedWorktree || !input.hasBaselineRef) {
+    return {
+      action: "skip",
+      reason: "skip_missing_worktree",
+      summary: "Skipped repair loop because retained worktree or baseline ref is unavailable",
+      ...baseEvidence
+    };
+  }
+  if (!input.providerExecutionSucceeded) {
+    return {
+      action: "skip",
+      reason: "skip_provider_failed",
+      summary: "Skipped repair loop because provider execution failed",
+      ...baseEvidence
+    };
+  }
+  if (!input.hasMaterializedDeliverable) {
+    return {
+      action: "skip",
+      reason: "skip_no_deliverable",
+      summary: "Skipped repair loop because provider produced no materialized deliverable",
+      ...baseEvidence
+    };
+  }
+  if (input.validationArtifactSatisfied === true) {
+    return {
+      action: "skip",
+      reason: "skip_validation_artifact_satisfied",
+      summary: "Skipped repair loop because validation artifact target is already satisfied",
+      ...baseEvidence
+    };
+  }
+  if (input.providerGatesAlreadyPassed) {
+    return {
+      action: "skip",
+      reason: "skip_passing_gates",
+      summary: "Skipped repair loop: provider verification already passed",
+      ...baseEvidence
+    };
+  }
+  if (input.verificationUnavailable) {
+    return {
+      action: "skip",
+      reason: "skip_verification_unavailable",
+      summary: "Skipped repair loop: verification is unavailable in this environment",
+      ...baseEvidence
+    };
+  }
+  if (input.hasMissingFileTargets && input.isClarifyingNoOp) {
+    return {
+      action: "skip",
+      reason: "skip_clarifying_noop",
+      summary: "Skipped repair loop: missing FILE targets + clarifying no-op response",
+      ...baseEvidence
+    };
+  }
+  return {
+    action: "run",
+    reason: "run_gate_failure",
+    summary: "Repair loop admitted for deterministic gate failure",
+    ...baseEvidence
+  };
+}
+function repairPolicyCompletionMode() {
+  const raw = readEnv(BUILD_COMPLETION_MODE).value;
+  return raw === "branch" || raw === "pr" || raw === "isolated" ? raw : "isolated";
+}
+function isOffScopeRepairOverrideEnabled() {
+  return readEnv(BUILD_ALLOW_OFF_SCOPE_REPAIR).value === true;
+}
+function resolveRepairPromotionPolicy(input) {
+  const outsideFiles = input.repairDelta?.filesOutsidePreRepairDiff ?? [];
+  const mechanicalFiles = new Set(input.repairDelta?.mechanicalAllowlistMatches ?? []);
+  const strictScopeExpansion = input.scopePolicy === "strict" && outsideFiles.some((file) => !mechanicalFiles.has(file));
+  const classificationForPolicy = strictScopeExpansion && input.classification !== "off_scope" ? "off_scope" : input.classification;
+  const policy = resolveRepairArtifactPolicy({
+    classification: classificationForPolicy,
+    effectiveMode: input.effectiveMode,
+    allowOffScopeRepair: input.allowOffScopeRepair
+  });
+  return strictScopeExpansion ? {
+    ...policy,
+    reason: `${policy.reason}; strict repair scope forbids non-mechanical files outside the provider diff`
+  } : policy;
+}
+async function readWorktreeHeadCommit(worktreePath) {
+  const head = await execa3("git", ["rev-parse", "HEAD"], {
+    cwd: worktreePath,
+    stdio: "pipe",
+    reject: false
+  });
+  if ((head.exitCode ?? 1) !== 0) return void 0;
+  const commit = String(head.stdout ?? "").trim();
+  return commit.length > 0 ? commit : void 0;
+}
+async function captureRepairDiffSnapshot(worktreePath, baselineRef) {
+  try {
+    const [commit, diff] = await Promise.all([
+      readWorktreeHeadCommit(worktreePath),
+      captureWorktreeDiff(worktreePath, baselineRef, true)
+    ]);
+    return buildRepairDiffSnapshot(diff, commit);
+  } catch {
+    return void 0;
+  }
+}
+function buildRepairTriggerEvidence(repairOutcome) {
+  const firstIteration = repairOutcome.verificationLoop?.iterations?.[0];
+  const stopReason = typeof repairOutcome.verificationLoop?.stopReason === "string" ? repairOutcome.verificationLoop.stopReason : void 0;
+  if (!firstIteration) {
+    return {
+      type: "unknown",
+      gateId: "verification-loop",
+      summary: stopReason ? `Verification-driven repair loop recorded no iterations; stopReason=${stopReason}` : "Verification-driven repair loop recorded no iterations"
+    };
+  }
+  const failedGate = firstIteration.build?.status !== "passed" ? "build" : firstIteration.lint && firstIteration.lint.status !== "passed" ? "lint" : firstIteration.tests && firstIteration.tests.status !== "passed" ? "test" : void 0;
+  if (!failedGate) {
+    return {
+      type: "policy",
+      gateId: "verification-loop",
+      summary: stopReason ? `Verification policy ran without an initial gate failure; stopReason=${stopReason}` : "Verification policy ran without an initial gate failure"
+    };
+  }
+  const failedConstraintCheck = firstIteration.build?.command === "constraint-check" || firstIteration.lint?.command === "constraint-check" || firstIteration.tests?.command === "constraint-check";
+  if (failedConstraintCheck) {
+    return {
+      type: "policy",
+      gateId: "constraint-check",
+      summary: stopReason ? `Verification repair was triggered by policy constraint failure; stopReason=${stopReason}` : "Verification repair was triggered by policy constraint failure"
+    };
+  }
+  return {
+    type: "gate_failure",
+    gateId: failedGate,
+    summary: stopReason ? `Verification repair was triggered by initial ${failedGate} gate failure; stopReason=${stopReason}` : `Verification repair was triggered by initial ${failedGate} gate failure`
+  };
+}
+async function taskScopedChangedFiles(worktreePath, baselineRef) {
+  try {
+    const diff = await captureWorktreeDiff(worktreePath, baselineRef, true);
+    if (!diff || diff.trim().length === 0) return [];
+    return extractChangedFilesMeta(diff).map((meta) => meta.path).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function coerceComparisonGateStatus(status) {
+  switch (status) {
+    case "passed":
+    case "failed":
+    case "skipped":
+    case "timeout":
+    case "error":
+    case "unavailable":
+    case "not_run":
+      return status;
+    default:
+      return void 0;
+  }
+}
+function statusFromExitCode(exitCode) {
+  return exitCode === 0 ? "passed" : "failed";
+}
+function toGateArtifactStatus(status) {
+  return status === "not_run" ? "skipped" : status;
+}
+function verificationBaselineCacheDir() {
+  return path2.join(resolveBuildDirFromContext(), "cache", "verification-baseline");
+}
+async function attachBaselineComparisonIfAvailable(result) {
+  const baselineRef = typeof result.baselineRef === "string" ? result.baselineRef.trim() : "";
+  if (!baselineRef) return;
+  const last = latestVerificationIteration(result.verificationLoop);
+  if (!last) return;
+  if (shouldTrustVerificationLoopBaseline(result)) {
+    result.baselineComparison = trustedLoopBaselineComparison(baselineRef, last);
+    return;
+  }
+  const repoRoot = process.cwd();
+  const cacheDir = verificationBaselineCacheDir();
+  const changedFiles = typeof result.worktreeDiff === "string" && result.worktreeDiff.trim().length > 0 ? extractChangedFilesMeta(result.worktreeDiff).map((meta) => meta.path).filter(Boolean) : [];
+  const baseline = await getOrCaptureVerificationBaseline({
+    repoRoot,
+    baselineRef,
+    cacheDir,
+    captureOptions: { changedFiles }
+  });
+  if (!baseline.metadata?.captureSucceeded) return;
+  const currentArtifacts = {
+    build: {
+      exitCode: last.build.exitCode,
+      outputTail: last.build.outputTail,
+      command: last.build.command,
+      durationMs: 0,
+      stdoutTail: "",
+      stderrTail: "",
+      language: last.build.language,
+      status: toGateArtifactStatus(
+        coerceComparisonGateStatus(last.build.status) ?? statusFromExitCode(last.build.exitCode)
+      )
+    },
+    lint: last.lint ? {
+      exitCode: last.lint.exitCode,
+      outputTail: last.lint.outputTail,
+      command: last.lint.command,
+      durationMs: 0,
+      language: last.lint.language,
+      status: toGateArtifactStatus(
+        coerceComparisonGateStatus(last.lint.status) ?? statusFromExitCode(last.lint.exitCode)
+      )
+    } : void 0,
+    tests: last.tests ? {
+      exitCode: last.tests.exitCode,
+      status: toGateArtifactStatus(
+        coerceComparisonGateStatus(last.tests.status) ?? statusFromExitCode(last.tests.exitCode)
+      ),
+      failingTests: last.tests.failingTests,
+      failingTestIdentities: last.tests.failingTestIdentities,
+      outputTail: last.tests.outputTail,
+      command: last.tests.command,
+      durationMs: 0,
+      language: last.tests.language
+    } : void 0
+  };
+  const currentOutcomes = verificationOutcomesFromGateArtifacts(currentArtifacts, {
+    cwd: repoRoot,
+    source: "variant-worker"
+  });
+  const stableComparison = compareVerificationOutcomeToBaseline(baseline, currentOutcomes);
+  result.baselineComparison = markLintIdenticalToBase(
+    toBaselineComparisonResult(stableComparisonToBaselineComparison(stableComparison)),
+    // Per-command lint results, so a lint gate of several commands is never matched.
+    channelsFailingIdenticallyOnBase(
+      baseline,
+      {
+        ...currentArtifacts,
+        lint: currentArtifacts.lint && {
+          ...currentArtifacts.lint,
+          // The loop records the gate as run; its stored type lags the per-command field.
+          commandResults: last.lint?.commandResults
+        }
+      },
+      ["lint"],
+      [repoRoot]
+    )
+  );
+}
+async function applyRegistryDowngradeIfApplicable(result) {
+  const comparison = result.baselineComparison;
+  if (!comparison || comparison.summary.shouldPenalize !== true) return;
+  const testNewFailures = comparison.tests?.newFailures ?? [];
+  if (testNewFailures.length === 0) return;
+  if ((comparison.types?.newFailures?.length ?? 0) > 0) return;
+  if ((comparison.lint?.newFailures?.length ?? 0) > 0) return;
+  const last = latestVerificationIteration(result.verificationLoop);
+  const testOutputTail = last?.tests?.outputTail ?? "";
+  const registry = await loadKnownPreExistingFailures(process.cwd());
+  const baselineRef = (result.baselineRef ?? comparison.baselineRef)?.trim().toLowerCase();
+  const registryBaseCommit = registry.baseCommit?.trim().toLowerCase();
+  const MIN_SHA_PREFIX_LEN = 7;
+  if (!baselineRef || !registryBaseCommit || baselineRef.length < MIN_SHA_PREFIX_LEN || registryBaseCommit.length < MIN_SHA_PREFIX_LEN || !baselineRef.startsWith(registryBaseCommit) && !registryBaseCommit.startsWith(baselineRef)) {
+    return;
+  }
+  if (!allFailuresAreRegistered(testNewFailures, registry, testOutputTail)) {
+    return;
+  }
+  applyKnownFailureDowngrade(comparison, testNewFailures.length);
+  const matchedNames = testNewFailures.join(", ");
+  process.stderr.write(
+    `[build:registry] Downgraded shouldPenalize=true \u2192 false for ${testNewFailures.length} registered failure(s): ${matchedNames}
+`
+  );
+}
+function getWarningCodes(result) {
+  const warnings = result.warnings;
+  if (!Array.isArray(warnings)) return /* @__PURE__ */ new Set();
+  return new Set(
+    warnings.map((w) => w?.code).filter((code) => typeof code === "string" && code.trim().length > 0)
+  );
+}
+function looksLikeClarifyingQuestion(text) {
+  const lower = text.toLowerCase();
+  if (lower.includes("?")) return true;
+  return /(\bdoes(?:n't| not)\s+exist\b|\bnot\s+found\b|\bcannot\s+find\b|\bcan't\s+find\b|\bcould\s+you\s+clarify\b|\bplease\s+clarify\b|\bwhich\s+file\b|\bwhat\s+file\b)/i.test(
+    lower
+  );
+}
+initializeLabModeFromEnv("initializing-worker");
+function formatElapsedRuntime(elapsedMs) {
+  const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1e3));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes}m ${seconds}s`;
+}
+async function runWithTimeout(promise, timeoutMs, label) {
+  let timeoutHandle;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timeoutHandle = setTimeout(() => {
+          reject(new Error(`${label} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeoutHandle) {
+      clearTimeout(timeoutHandle);
+    }
+  }
+}
+function parseRepairLoopConfig() {
+  const enabledEnv = process.env.BUILD_REPAIR_LOOP_ENABLED;
+  const enabled = enabledEnv === "1";
+  const maxIterationsRaw = Number(process.env.BUILD_REPAIR_LOOP_MAX_ITERATIONS);
+  const maxIterations = Number.isFinite(maxIterationsRaw) && maxIterationsRaw > 0 ? maxIterationsRaw : DEFAULT_REPAIR_LOOP_MAX_ITERATIONS;
+  const iterationTimeoutMsRaw = Number(process.env.BUILD_REPAIR_LOOP_ITERATION_TIMEOUT_MS);
+  const iterationTimeoutMs = Number.isFinite(iterationTimeoutMsRaw) && iterationTimeoutMsRaw > 0 ? iterationTimeoutMsRaw : DEFAULT_REPAIR_LOOP_ITERATION_TIMEOUT_MS;
+  const abortIfRegression = process.env.BUILD_REPAIR_LOOP_ABORT_IF_REGRESSION !== "0";
+  const allowApiBreak = process.env.BUILD_ALLOW_API_BREAK === "1";
+  const repairModeEnv = process.env.BUILD_REPAIR_MODE;
+  const repairMode = repairModeEnv === "strict" || repairModeEnv === "none" || repairModeEnv === "auto" ? repairModeEnv : "auto";
+  const scopePolicyEnv = process.env.BUILD_REPAIR_SCOPE_POLICY;
+  const scopePolicy = scopePolicyEnv === "expand" ? "expand" : "strict";
+  const saveModesEnv = process.env.BUILD_REPAIR_SAVE_MODES;
+  const repairSaveModes = (saveModesEnv?.trim().length ? saveModesEnv : "patch").split(",").map((m) => m.trim()).filter(Boolean).filter((m) => m === "patch" || m === "ref" || m === "branch");
+  const normalizedRepairSaveModes = repairSaveModes.length > 0 ? repairSaveModes : ["patch"];
+  return {
+    enabled,
+    maxIterations,
+    iterationTimeoutMs,
+    abortIfRegression,
+    allowApiBreak,
+    repairMode,
+    scopePolicy,
+    repairSaveModes: [...normalizedRepairSaveModes]
+  };
+}
+async function tryCleanupRetainedWorktree(worktreePath, verbose) {
+  const normalized = path2.resolve(worktreePath);
+  const buildRoot = resolveBuildRoot();
+  const allowedRoots = [
+    path2.resolve(getWorktreeBaseDir(buildRoot)),
+    path2.resolve(buildRoot, ".build-project", "tmp", "worktrees"),
+    path2.resolve(buildRoot, "build-worktrees"),
+    path2.join("/tmp", "build-worktrees"),
+    path2.join(process.env.TMPDIR ?? "/tmp", "build-worktrees")
+  ];
+  const allowed = allowedRoots.some((root) => {
+    const rootWithSep = root.endsWith(path2.sep) ? root : `${root}${path2.sep}`;
+    return normalized === root || normalized.startsWith(rootWithSep);
+  });
+  if (!allowed) {
+    if (verbose) {
+      console.warn(
+        chalk.yellow(`Refusing to cleanup retained worktree outside known roots: ${worktreePath}`)
+      );
+    }
+    return;
+  }
+  try {
+    await execa3("git", ["worktree", "remove", "--force", normalized], {
+      cwd: buildRoot,
+      stdio: "pipe",
+      timeout: 3e4,
+      reject: false
+    });
+  } catch (error) {
+    if (verbose) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.warn(chalk.yellow(`Failed to cleanup retained worktree: ${msg}`));
+    }
+  }
+}
+async function ensureGitMetrics(result) {
+  if (result.gitMetrics) return;
+  const worktreePath = result.retainedWorktreePath;
+  if (worktreePath) {
+    const summary = await getGitChangeSummary(worktreePath, result.baselineRef, true);
+    if (summary.filesChanged > 0) {
+      result.gitMetrics = {
+        filesChanged: summary.filesChanged,
+        linesAdded: summary.linesAdded,
+        linesDeleted: summary.linesRemoved,
+        source: summary.source === "fallback" ? "unknown" : "worktree"
+      };
+      return;
+    }
+  }
+  if (result.worktreeSummary) {
+    result.gitMetrics = {
+      filesChanged: result.worktreeSummary.filesChanged,
+      linesAdded: result.worktreeSummary.insertions,
+      linesDeleted: result.worktreeSummary.deletions,
+      source: "unknown"
+    };
+  }
+}
+async function findVariantWorktreePathForTimeout(taskId, variant, repoRoot) {
+  try {
+    const listResult = await execa3("git", ["worktree", "list", "--porcelain"], {
+      cwd: repoRoot,
+      reject: false,
+      timeout: PARTIAL_GIT_TIMEOUT_MS
+    });
+    if ((listResult.exitCode ?? 0) !== 0 || !listResult.stdout?.trim()) {
+      return void 0;
+    }
+    const expectedBranch = generateBranchName(taskId, variant);
+    return parseGitWorktreeBranches(listResult.stdout).find(
+      (entry) => entry.branch === expectedBranch
+    )?.path;
+  } catch {
+    return void 0;
+  }
+}
+async function main() {
+  const program = new Command();
+  program.name("variant-worker").description("Execute a single variant task and write result to file").requiredOption("--task-id <id>", "Task identifier").requiredOption("--variant <json>", "Variant configuration as JSON string").requiredOption("--prompt-file <path>", "Path to file containing prompt text").option(
+    "--original-task-file <path>",
+    "Path to file containing the original task text before prompt injection"
+  ).requiredOption("--result-file <path>", "Path to write result JSON").option(
+    "--partial-result-file <path>",
+    "Path to write timeout-partial result JSON (best-effort)"
+  ).option("--timeout-minutes <minutes>", "Execution timeout in minutes", parseFloat).option("--deadline-at <epochMs>", "Absolute provider deadline (epoch ms)", parseFloat).option(
+    "--idle-warn-minutes <minutes>",
+    "Provider idle warning threshold in minutes",
+    parseFloat
+  ).option("--idle-kill-minutes <minutes>", "Provider idle stop threshold in minutes", parseFloat).option("--verbose", "Enable verbose logging", false).action(async (options) => {
+    await executeWorker(options);
+  });
+  await program.parseAsync(process.argv);
+}
+async function warnOnce(message, state) {
+  if (state.warned) return;
+  state.warned = true;
+  console.log(chalk.yellow(message));
+}
+var RESULT_PERSISTENCE_PATH_KEYS = /* @__PURE__ */ new Set([
+  "artifactManifest",
+  "resultFile",
+  "resultPath",
+  "retainedWorktreePath",
+  "worktreePath"
+]);
+function shouldPreserveResultPersistenceString(key) {
+  return key !== void 0 && RESULT_PERSISTENCE_PATH_KEYS.has(key);
+}
+function serializeErrorForJson(error) {
+  if (error instanceof Error) {
+    const sanitized = sanitizeError(error);
+    const serialized = {
+      name: sanitized.name,
+      message: sanitized.message,
+      stack: sanitized.stack
+    };
+    if (error instanceof HostTimeoutError) {
+      serialized.reason = "timeout";
+      serialized.limitMs = error.limitMs;
+      serialized.source = error.source;
+      serialized.parsedError = createHostTerminationParsedError("timeout", sanitized.message, {
+        limitMs: error.limitMs
+      });
+    }
+    if (error instanceof ProviderExecutionError) {
+      serialized.code = error.code;
+      serialized.reason = sanitizeSynthesisArtifactForPersistence(error.reason);
+      serialized.retryable = error.retryable;
+      serialized.exitCode = error.exitCode;
+      serialized.statusCode = error.statusCode;
+      serialized.idleTerminated = error.idleTerminated;
+      serialized.signal = sanitizeSynthesisArtifactForPersistence(error.signal);
+      serialized.terminationSource = sanitizeSynthesisArtifactForPersistence(
+        error.terminationSource
+      );
+      serialized.context = sanitizeSynthesisArtifactForPersistence(error.context);
+      serialized.parsedError = sanitizeSynthesisArtifactForPersistence(error.parsedError);
+    }
+    return serialized;
+  }
+  return sanitizeSynthesisArtifactForPersistence(error);
+}
+function sanitizeResultPayloadForJson(value, seen = /* @__PURE__ */ new WeakSet(), key = void 0) {
+  if (value instanceof Error) {
+    return serializeErrorForJson(value);
+  }
+  if (typeof value === "string") {
+    return shouldPreserveResultPersistenceString(key) ? value : sanitizeSynthesisStringForPersistence(value);
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (typeof value === "boolean" || value === null) {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "symbol" || typeof value === "function" || value === void 0) {
+    return void 0;
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (seen.has(value)) {
+    return "[Circular]";
+  }
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      return value.map((entry) => sanitizeResultPayloadForJson(entry, seen, key));
+    }
+    const sanitized = {};
+    for (const [entryKey, entry] of Object.entries(value)) {
+      const sanitizedEntry = entryKey === "error" ? serializeErrorForJson(entry) : sanitizeResultPayloadForJson(entry, seen, entryKey);
+      const finalValue = isSensitiveKey(entryKey) ? "[REDACTED]" : sanitizedEntry;
+      if (finalValue !== void 0) {
+        sanitized[entryKey] = finalValue;
+      }
+    }
+    const original = value;
+    if (typeof original.worktreeDiff === "string") {
+      sanitized.worktreeDiffReplayable = original.worktreeDiffReplayable !== false && sanitized.worktreeDiff === original.worktreeDiff;
+    }
+    return sanitized;
+  } finally {
+    seen.delete(value);
+  }
+}
+async function writeResultFileAtomically(resultPath, payload) {
+  const resultJson = JSON.stringify(sanitizeResultPayloadForJson(payload), null, 2);
+  const tmpFile = `${resultPath}.tmp.${randomBytes(4).toString("hex")}`;
+  await fs2.writeFile(tmpFile, resultJson, "utf-8");
+  const fd = openSync(tmpFile, "r+");
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  await fs2.rename(tmpFile, resultPath);
+}
+var __testOnlyWriteResultFileAtomically = writeResultFileAtomically;
+function formatVerboseWorkerCompletionMetric(result) {
+  return `Completeness: ${result.completeness.toFixed(1)}%`;
+}
+function initializeWorkerExecutionContext(taskId) {
+  const inheritedBuildDir = readEnv(BUILD_TELEMETRY_DIR).value?.trim();
+  if (!inheritedBuildDir) return;
+  setExecutionContext(
+    createExecutionContext({
+      repoRoot: resolveCliRepoRoot(process.cwd()),
+      buildDir: inheritedBuildDir,
+      taskId
+    })
+  );
+}
+async function executeWorker(options) {
+  const {
+    taskId,
+    variant: variantJson,
+    promptFile,
+    originalTaskFile,
+    resultFile,
+    timeoutMinutes,
+    deadlineAt,
+    idleWarnMinutes,
+    idleKillMinutes,
+    verbose
+  } = options;
+  const repairLoopConfig = parseRepairLoopConfig();
+  if (idleWarnMinutes == null !== (idleKillMinutes == null)) {
+    throw new Error("--idle-warn-minutes and --idle-kill-minutes must be provided together");
+  }
+  initializeWorkerExecutionContext(taskId);
+  initializeLabModeFromEnv(taskId);
+  if (verbose) {
+    console.log(chalk.blue("Variant Worker starting"));
+    console.log(chalk.gray(`   Task ID: ${taskId}`));
+    console.log(chalk.gray(`   Prompt: ${promptFile}`));
+    console.log(chalk.gray(`   Result: ${resultFile}`));
+    console.log(
+      chalk.gray(`   Partial Result: ${options.partialResultFile ?? `${resultFile}.partial.json`}`)
+    );
+  }
+  let variant;
+  try {
+    variant = parseJsonWithContext(
+      variantJson,
+      "[Variant Worker] variant configuration"
+    );
+  } catch (error) {
+    throw new Error(
+      `Invalid variant JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const workerProcessLifecycle = new ProcessLifecycleManager({
+    verbose: verbose === true,
+    defaultTimeoutMinutes: timeoutMinutes ?? DEFAULT_PER_VARIANT_TIMEOUT_MINUTES,
+    maxConcurrentProcesses: 10,
+    cleanupOnTermination: true
+  });
+  setProcessLifecycleManager(workerProcessLifecycle);
+  const processLifecycleSignalHandlerName = "variant-worker-process-lifecycle";
+  const signalHandlerName = "variant-worker-timeout-partial-result";
+  let postProviderSignalHandlersInstalled = false;
+  const onPostProviderSigterm = () => {
+    void postProviderShutdown?.("SIGTERM");
+  };
+  const onPostProviderSigint = () => {
+    void postProviderShutdown?.("SIGINT");
+  };
+  let postProviderShutdown;
+  const installPostProviderSignalHandlers = () => {
+    if (postProviderSignalHandlersInstalled) return;
+    signalCoordinator.suspendProcessSignalHandlers();
+    process.on("SIGTERM", onPostProviderSigterm);
+    process.on("SIGINT", onPostProviderSigint);
+    postProviderSignalHandlersInstalled = true;
+  };
+  const uninstallPostProviderSignalHandlers = () => {
+    if (!postProviderSignalHandlersInstalled) return;
+    process.removeListener("SIGTERM", onPostProviderSigterm);
+    process.removeListener("SIGINT", onPostProviderSigint);
+    signalCoordinator.resumeProcessSignalHandlers();
+    postProviderSignalHandlersInstalled = false;
+  };
+  signalCoordinator.register(
+    processLifecycleSignalHandlerName,
+    async (context) => {
+      if (context.reason === "SIGTERM" || context.reason === "SIGINT") {
+        await workerProcessLifecycle.handleSignal(context.reason);
+        return;
+      }
+      await workerProcessLifecycle.close();
+    },
+    { priority: "critical", phase: "process-termination" }
+  );
+  try {
+    variant.nativeWebSearch = isNativeResearchEnabledFor(variant.provider);
+    const runMode = variant.isBasicCompetition ? "basic-cli-native" : "advanced";
+    const partialResultFile = typeof options.partialResultFile === "string" && options.partialResultFile.trim().length > 0 ? options.partialResultFile.trim() : `${resultFile}.partial.json`;
+    const workerStartMs = Date.now();
+    const startTime = process.hrtime.bigint();
+    const timeoutContext = {};
+    let executorSettled = false;
+    const persistTimeoutPartialResult = async (signal = "SIGTERM") => {
+      const cancelled = signal === "SIGINT";
+      const stopVerb = cancelled ? "Cancelled" : "Timed out";
+      const timeoutWorktreeCandidate = timeoutContext.worktreePath ?? variant.workflowWorktreePath;
+      let timeoutWorktreePath = typeof timeoutWorktreeCandidate === "string" && timeoutWorktreeCandidate.trim().length > 0 ? timeoutWorktreeCandidate.trim() : void 0;
+      if (!timeoutWorktreePath) {
+        timeoutWorktreePath = await findVariantWorktreePathForTimeout(
+          taskId,
+          variant,
+          process.cwd()
+        );
+        if (!timeoutWorktreePath && verbose) {
+          console.warn("[partial-save] Worktree context unavailable; needle discovery also failed");
+        }
+      }
+      const elapsedText = formatElapsedRuntime(Date.now() - workerStartMs);
+      let filesChanged = 0;
+      let linesAdded = 0;
+      let linesRemoved = 0;
+      let statusLines = [];
+      let partialEdits = false;
+      let autoCommitFailed = false;
+      let worktreeDiff;
+      let baselineRef = typeof timeoutContext.baselineRef === "string" && timeoutContext.baselineRef.trim().length > 0 ? timeoutContext.baselineRef.trim() : void 0;
+      let partialErrorDetail;
+      if (timeoutWorktreePath) {
+        try {
+          const canMutateWorktreeForSnapshot = executorSettled;
+          if (canMutateWorktreeForSnapshot) {
+            await stageCommitEligibleChanges(timeoutWorktreePath);
+          } else {
+            partialErrorDetail = "executor still running during timeout; skipped git add/commit partial snapshot";
+          }
+          const [cachedStat, cachedShortStat, statusResult] = await Promise.all([
+            execa3(
+              "git",
+              canMutateWorktreeForSnapshot ? ["diff", "--cached", "--stat"] : ["diff", "--stat"],
+              {
+                cwd: timeoutWorktreePath,
+                stdio: "pipe",
+                reject: false,
+                timeout: 1200
+              }
+            ),
+            execa3(
+              "git",
+              canMutateWorktreeForSnapshot ? ["diff", "--cached", "--shortstat"] : ["diff", "--shortstat"],
+              {
+                cwd: timeoutWorktreePath,
+                stdio: "pipe",
+                reject: false,
+                timeout: 1200
+              }
+            ),
+            execa3("git", ["status", "--porcelain", "--untracked-files=all"], {
+              cwd: timeoutWorktreePath,
+              stdio: "pipe",
+              reject: false,
+              timeout: 1200
+            })
+          ]);
+          partialEdits = cachedStat.stdout.trim().length > 0;
+          const parsedShortStat = parseShortStatSummary(cachedShortStat.stdout);
+          filesChanged = parsedShortStat.filesChanged;
+          linesAdded = parsedShortStat.linesAdded;
+          linesRemoved = parsedShortStat.linesRemoved;
+          statusLines = statusResult.stdout.split("\n").map((line) => line.trimEnd()).filter((line) => line.trim().length > 0);
+          if (partialEdits && filesChanged === 0 && statusLines.length > 0) {
+            filesChanged = statusLines.length;
+          }
+          if (partialEdits && canMutateWorktreeForSnapshot) {
+            const commitMessage = `chore: partial work (${cancelled ? "cancelled" : "timeout"} at ${elapsedText})`;
+            const commit = await execa3("git", ["commit", "--no-verify", "-m", commitMessage], {
+              cwd: timeoutWorktreePath,
+              stdio: "pipe",
+              reject: false,
+              timeout: 1500
+            });
+            ({ autoCommitFailed, baselineRef } = await resolveTimeoutSnapshotCommit(
+              commit,
+              baselineRef,
+              async () => {
+                const parent = await execa3("git", ["rev-parse", "HEAD~1"], {
+                  cwd: timeoutWorktreePath,
+                  stdio: "pipe",
+                  reject: false,
+                  timeout: 1200
+                });
+                return parent.exitCode === 0 && parent.stdout.trim().length > 0 ? parent.stdout.trim() : void 0;
+              }
+            ));
+            try {
+              const diffText = await captureWorktreeDiff(timeoutWorktreePath, baselineRef, true);
+              if (diffText.trim().length > 0) {
+                worktreeDiff = normalizeWorktreeDiff(diffText);
+              }
+            } catch {
+            }
+          }
+        } catch (error) {
+          partialErrorDetail = error instanceof Error ? error.message : String(error);
+        }
+      }
+      if (!partialErrorDetail && partialEdits) {
+        if (autoCommitFailed) {
+          partialErrorDetail = "auto-commit failed";
+        }
+      }
+      const completeness = partialEdits ? estimateTimeoutCompletenessFromScope({
+        filesChanged,
+        linesAdded,
+        linesRemoved,
+        statusEntries: statusLines.length
+      }) : 0;
+      const timeoutErrorMessage = (() => {
+        if (partialErrorDetail) {
+          if (partialEdits && !autoCommitFailed) {
+            return `${stopVerb} at ${elapsedText}; partial edits detected (preservation warning: ${partialErrorDetail})`;
+          }
+          if (partialEdits && autoCommitFailed) {
+            return `${stopVerb} at ${elapsedText}; partial edits detected but auto-commit failed`;
+          }
+          return `${stopVerb} at ${elapsedText}; partial preservation warning: ${partialErrorDetail}`;
+        }
+        if (partialEdits) {
+          return `${stopVerb} at ${elapsedText}; partial edits preserved`;
+        }
+        return `${stopVerb} at ${elapsedText}; no staged edits detected`;
+      })();
+      const partialResult = {
+        variant: formatVariantIdentifier(variant),
+        provider: variant.provider,
+        model: variant.model,
+        executionMode: variant.executionMode,
+        success: false,
+        duration: Number(process.hrtime.bigint() - startTime) / 1e9,
+        completeness,
+        timedOut: !cancelled,
+        partialEdits,
+        terminationReason: cancelled ? "canceled_user" : "timeout",
+        executionIntent: variant.executionIntent,
+        isBasicCompetition: variant.isBasicCompetition,
+        emptyChanges: !partialEdits,
+        filesChanged,
+        linesAdded,
+        linesRemoved,
+        worktreeDiff,
+        gitMetrics: partialEdits ? {
+          filesChanged,
+          linesAdded,
+          linesDeleted: linesRemoved,
+          source: "worktree"
+        } : void 0,
+        worktreeSummary: timeoutWorktreePath ? {
+          filesChanged,
+          insertions: linesAdded,
+          deletions: linesRemoved,
+          statusLines
+        } : void 0,
+        retainedWorktreePath: timeoutWorktreePath,
+        baselineRef,
+        error: cancelled ? new Error(timeoutErrorMessage) : new HostTimeoutError(timeoutErrorMessage, {
+          source: VARIANT_WORKER_SIGTERM_SOURCE
+        })
+      };
+      partialResult.outcome = deriveVariantOutcome(partialResult);
+      sanitizeVariantResult(partialResult);
+      await writeResultFileAtomically(partialResultFile, partialResult);
+    };
+    const executionAbortController = new AbortController();
+    let shutdownRequested = false;
+    let shutdownRequestedAtMs;
+    let shutdownSignal;
+    const signalExitCode = (signal) => signal === "SIGINT" ? 130 : 143;
+    const requestShutdown = async (signal, options2) => {
+      if (shutdownRequested) {
+        return;
+      }
+      shutdownRequested = true;
+      shutdownRequestedAtMs = elapsedMsSince(startTime);
+      shutdownSignal = signal;
+      if (signal === "SIGINT") {
+        mergeExecutionContextEnvOverrides({ BUILD_PRESERVE_WORKTREES: "1" });
+      }
+      if (!executionAbortController.signal.aborted) {
+        executionAbortController.abort(buildShutdownAbortReason(signal));
+      }
+      const exitAfter = options2?.exitAfter ?? true;
+      try {
+        if (verbose) {
+          console.log(chalk.yellow(`Received ${signal}; beginning timeout shutdown handling.`));
+        }
+        try {
+          await runWithTimeout(persistTimeoutPartialResult(signal), 2500, "partial result save");
+          if (verbose) {
+            console.log(chalk.gray(`   Partial timeout result written to ${partialResultFile}`));
+          }
+        } catch (error) {
+          if (verbose) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(chalk.yellow(`Partial timeout preservation skipped: ${message}`));
+          }
+        }
+        if (exitAfter) {
+          try {
+            await runWithTimeout(
+              signalCoordinator.runCleanupHandlers(`variant-worker ${signal.toLowerCase()}`, {
+                timeoutMs: SIGNAL_CLEANUP_TIMEOUT_MS
+              }),
+              SIGNAL_CLEANUP_WRAPPER_TIMEOUT_MS,
+              "signal cleanup"
+            );
+          } catch {
+          }
+        }
+      } catch (shutdownError) {
+        console.error(
+          `[variant-worker] Shutdown error (${signal}): ${shutdownError instanceof Error ? shutdownError.message : String(shutdownError)}`
+        );
+      } finally {
+        if (exitAfter) {
+          process.exit(signalExitCode(signal));
+        }
+      }
+    };
+    postProviderShutdown = async (signal) => {
+      await requestShutdown(signal, { exitAfter: false });
+    };
+    signalCoordinator.register(
+      signalHandlerName,
+      async (context) => {
+        if (context.reason === "SIGTERM" || context.reason === "SIGINT") {
+          await requestShutdown(context.reason, { exitAfter: false });
+        }
+      },
+      { priority: "critical", phase: "artifact-cleanup" }
+    );
+    if (variant.executionMode !== "local") {
+      throw new Error(`Worker only supports local execution mode (got: ${variant.executionMode})`);
+    }
+    let prompt;
+    try {
+      prompt = await fs2.readFile(promptFile, "utf-8");
+    } catch (error) {
+      throw new Error(
+        `Failed to read prompt file: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    if (verbose) {
+      console.log(chalk.blue(`Loaded prompt (${prompt.length} chars)`));
+      console.log(chalk.blue(`Executing ${formatVariantIdentifier(variant)}...`));
+    }
+    const repoRoot = process.cwd();
+    const packageJsonScripts = await tryLoadPackageJsonScripts(repoRoot);
+    let originalPrompt;
+    if (originalTaskFile) {
+      try {
+        originalPrompt = await fs2.readFile(originalTaskFile, "utf-8");
+      } catch (error) {
+        throw new Error(
+          `Failed to read original task file: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    } else {
+      originalPrompt = extractOriginalPrompt(prompt);
+    }
+    const specInjectionUsed = /\[SPEC:/.test(prompt);
+    const specSignal = evaluateExecutionSpec(originalPrompt);
+    let guidanceTier;
+    let specQualitySignals;
+    if (specSignal) {
+      guidanceTier = specSignal.guidanceTier;
+      specQualitySignals = generateSpecQualitySignals(originalPrompt, repoRoot, packageJsonScripts);
+    }
+    const classification = classifyTask(prompt, { stripInjections: true });
+    let telemetry = null;
+    let telemetryEnabled = true;
+    const telemetryWarning = { warned: false };
+    const costTrackerWarning = { warned: false };
+    const applyWorkerEnvOverrides = (overrides) => {
+      mergeExecutionContextEnvOverrides(overrides);
+    };
+    const prevRetainBasicWorktree = getRuntimeEnv("BUILD_RETAIN_BASIC_WORKTREE");
+    const prevPreserveWorktrees = getRuntimeEnv("BUILD_PRESERVE_WORKTREES");
+    const preserveWorktreesForDebug = prevRetainBasicWorktree === "1" && getRuntimeEnv("BUILD_PRESERVE_WORKTREES") !== "1";
+    if (preserveWorktreesForDebug) {
+      applyWorkerEnvOverrides({ BUILD_PRESERVE_WORKTREES: "1" });
+    }
+    try {
+      telemetry = TelemetryLogger.getInstance();
+      telemetry.logVariantEvent(taskId, formatVariantIdentifier(variant), "started", {
+        provider: variant.provider,
+        model: variant.model,
+        executionMode: variant.executionMode,
+        runMode,
+        executionIntent: variant.executionIntent,
+        ...typeof guidanceTier === "number" ? { guidanceTier } : {},
+        ...specInjectionUsed ? { specInjectionUsed: true } : {},
+        ...Array.isArray(specQualitySignals) && specQualitySignals.length > 0 ? { specQualitySignals } : {},
+        ...classification.drift ? { classificationDrift: classification.drift } : {}
+      });
+    } catch (_err) {
+      await warnOnce(
+        "Telemetry unavailable for worker; continuing with JSON output only.",
+        telemetryWarning
+      );
+      telemetryEnabled = false;
+    }
+    let result;
+    let cleanupWorktreeAfterRun = false;
+    let executionResultSettledAtMs;
+    const providerOutputForwarder = createProviderOutputForwarder(
+      getRuntimeEnv("BUILD_PROVIDER_OUTPUT_EVENTS") === "1"
+    );
+    try {
+      const { LocalExecutor } = await import("./local-executor-DCMDDRX2.js");
+      if (repairLoopConfig.enabled && prevRetainBasicWorktree === void 0 && getRuntimeEnv("BUILD_RETAIN_BASIC_WORKTREE") !== "1") {
+        applyWorkerEnvOverrides({ BUILD_RETAIN_BASIC_WORKTREE: "1" });
+        cleanupWorktreeAfterRun = getRuntimeEnv("BUILD_PRESERVE_WORKTREES") !== "1";
+      }
+      let costTracker;
+      if (telemetry) {
+        try {
+          const { UnifiedCostTracker } = await import("./unified-cost-tracker-5MTBJ2CL.js");
+          const { UniversalCostCalculator } = await import("./universal-cost-calculator-JTFEJVWK.js");
+          const costCalculator = new UniversalCostCalculator(telemetry);
+          costTracker = new UnifiedCostTracker(costCalculator, telemetry, {
+            enabled: true,
+            budgetThresholds: {
+              warning: 1,
+              critical: 5,
+              daily: 10,
+              monthly: 100
+            },
+            optimization: {
+              enableSuggestions: false,
+              minSavingsThreshold: 1,
+              maxSuggestionsPerHour: 0
+            },
+            updateIntervalMs: 6e4
+          });
+        } catch (costErr) {
+          await warnOnce(
+            "Cost tracking initialization failed in worker; continuing without a UnifiedCostTracker.",
+            costTrackerWarning
+          );
+          if (verbose) {
+            const message = costErr instanceof Error ? costErr.message : String(costErr);
+            console.warn(chalk.yellow(`   Cost tracking init error: ${message}`));
+          }
+        }
+      }
+      const executor = new LocalExecutor({
+        repoRoot,
+        verbose: verbose ?? false,
+        executorTimeoutMs: timeoutMinutes != null ? timeoutMinutes * 6e4 : void 0,
+        executorDeadlineAt: deadlineAt ?? (timeoutMinutes != null ? workerStartMs + timeoutMinutes * 6e4 : void 0),
+        idleWarnMs: idleWarnMinutes != null ? idleWarnMinutes * 6e4 : void 0,
+        idleKillMs: idleKillMinutes != null ? idleKillMinutes * 6e4 : void 0,
+        costTracker,
+        resultStreamer: providerOutputForwarder.resultStreamer,
+        onWorktreeReady: ({ worktreePath, baselineRef }) => {
+          timeoutContext.worktreePath = worktreePath;
+          timeoutContext.baselineRef = baselineRef;
+        }
+      });
+      const executionBreadcrumb = createCliBreadcrumb({
+        label: `Variant ${formatVariantIdentifier(variant)}`,
+        detail: "execution started; this step can stay quiet while the provider works."
+      });
+      let execResult;
+      try {
+        execResult = await executor.executeVariant(taskId, variant, prompt, {
+          abortSignal: executionAbortController.signal
+        });
+        executionResultSettledAtMs = elapsedMsSince(startTime);
+        installPostProviderSignalHandlers();
+        executionBreadcrumb.complete();
+      } finally {
+        executorSettled = true;
+        executionBreadcrumb.dispose();
+      }
+      result = execResult;
+      const postProviderPhaseDurationsMs = {
+        ...result.postProviderPhaseDurationsMs ?? {}
+      };
+      result.postProviderPhaseDurationsMs = postProviderPhaseDurationsMs;
+      timeoutContext.worktreePath = result.retainedWorktreePath ?? timeoutContext.worktreePath;
+      timeoutContext.baselineRef = result.baselineRef ?? timeoutContext.baselineRef;
+      measurePostProviderPhaseSync(
+        postProviderPhaseDurationsMs,
+        "resultNormalization",
+        verbose,
+        () => {
+          if (variant.executionIntent === "analysis" && result.success !== false && (result.completeness ?? 0) < MIN_ANALYSIS_COMPLETENESS) {
+            const boosted = Math.max(result.completeness ?? 0, MIN_ANALYSIS_COMPLETENESS);
+            result.completeness = boosted;
+            result.completenessScore = {
+              score: boosted,
+              category: "analysis",
+              fileTargetMatchRate: result.completenessScore?.fileTargetMatchRate
+            };
+          }
+          if (result.completeness < 0) {
+            result.completeness = 0;
+          }
+        }
+      );
+      const duration = Number(process.hrtime.bigint() - startTime) / 1e9;
+      result.executionDurationMs = Math.round(duration * 1e3);
+      await measurePostProviderPhase(
+        postProviderPhaseDurationsMs,
+        "gitMetrics",
+        verbose,
+        async () => ensureGitMetrics(result)
+      );
+      attachOffScopeConfigWarning(result, { taskId, prompt });
+      const isAnalysisIntent = variant.executionIntent === "analysis";
+      const hasRetainedRepairWorktree = typeof result.retainedWorktreePath === "string" && result.retainedWorktreePath.trim().length > 0;
+      const hasRepairBaselineRef = typeof result.baselineRef === "string" && result.baselineRef.trim().length > 0;
+      const warningCodes = getWarningCodes(result);
+      const hasMissingFileTargets = warningCodes.has("WS-008");
+      const filesChanged = result.gitMetrics?.filesChanged ?? result.filesChanged ?? 0;
+      const hasMaterializedDeliverable = filesChanged > 0 || result.outcome?.delivery?.hasChanges === true;
+      const outputText = `${result.result?.stdout ?? ""}
+${result.result?.stderr ?? ""}`;
+      const isClarifyingNoOp = filesChanged === 0 && looksLikeClarifyingQuestion(outputText);
+      const exactArtifactGate = await measurePostProviderPhase(
+        postProviderPhaseDurationsMs,
+        "exactArtifactGoalGate",
+        verbose,
+        async () => {
+          if (!hasRetainedRepairWorktree) {
+            return { success: result.success === true };
+          }
+          return applyExactArtifactGoalSuccessGate({
+            prompt,
+            worktreePath: result.retainedWorktreePath,
+            success: result.success === true
+          });
+        }
+      );
+      if (result.success === true && !exactArtifactGate.success) {
+        result.success = false;
+        result.completeness = 0;
+        result.error = new Error(
+          exactArtifactGate.failureReason ?? "Exact artifact content mismatch"
+        );
+      }
+      const validationArtifactSatisfied = await measurePostProviderPhase(
+        postProviderPhaseDurationsMs,
+        "validationArtifactCheck",
+        verbose,
+        async () => {
+          if (!hasRetainedRepairWorktree || result.success !== true) return false;
+          const simpleArtifactGoal = parseSimpleArtifactGoal(prompt);
+          if (simpleArtifactGoal) {
+            return isSimpleArtifactGoalSatisfied(result.retainedWorktreePath, simpleArtifactGoal);
+          }
+          return isValidationArtifactOnlyDiffSatisfied({
+            prompt,
+            worktreePath: result.retainedWorktreePath,
+            baselineRef: result.baselineRef
+          });
+        }
+      );
+      const runFallbackVerification = async () => {
+        if (!result.verificationLoop && validationArtifactSatisfied !== true && !isAnalysisIntent && result.success === true && hasMaterializedDeliverable && typeof result.retainedWorktreePath === "string" && result.retainedWorktreePath.trim().length > 0 && typeof result.baselineRef === "string" && result.baselineRef.trim().length > 0) {
+          const worktreePath = result.retainedWorktreePath.trim();
+          const baselineRef = result.baselineRef.trim();
+          const repoRoot2 = process.cwd();
+          const cacheDir = verificationBaselineCacheDir();
+          const verificationChangedFiles = await taskScopedChangedFiles(worktreePath, baselineRef);
+          const testsProhibited = isTestRunProhibited(prompt);
+          const baselineForVerification = await measurePostProviderPhase(
+            postProviderPhaseDurationsMs,
+            "verificationBaselineCapture",
+            verbose,
+            async () => getOrCaptureVerificationBaseline({
+              repoRoot: repoRoot2,
+              baselineRef,
+              cacheDir,
+              captureOptions: {
+                changedFiles: verificationChangedFiles,
+                skipTests: testsProhibited
+              }
+            }).catch(() => null)
+          );
+          const verificationOutcome = await measurePostProviderPhase(
+            postProviderPhaseDurationsMs,
+            "deterministicVerification",
+            verbose,
+            async () => runDeterministicVerificationOnce({
+              worktreePath,
+              baselineRef,
+              // Same per-channel budget as the baseline capture above, not the
+              // repair-iteration timebox, so a gate the baseline passed is not cut short.
+              timeoutMs: resolveVerifyCommandTimeoutMs(),
+              budget: "per-channel",
+              baseline: baselineForVerification?.metadata?.captureSucceeded ? baselineForVerification : void 0,
+              checkTestGate: !testsProhibited,
+              // Same scope as the baseline capture above (symmetry invariant).
+              changedFiles: verificationChangedFiles
+            })
+          );
+          result.verification = verificationOutcome.verification;
+          result.verificationLoop = verificationOutcome.verificationLoop;
+        }
+      };
+      const initialVerificationDisposition = await resolveInitialVerificationDisposition(
+        result,
+        runFallbackVerification
+      );
+      const providerGatesAlreadyPassed = initialVerificationDisposition.outcome === "passed";
+      const repairAdmission = measurePostProviderPhaseSync(
+        postProviderPhaseDurationsMs,
+        "repairAdmission",
+        verbose,
+        () => {
+          return decideRepairAdmission({
+            repairLoopEnabled: repairLoopConfig.enabled,
+            isAnalysisIntent,
+            hasRetainedWorktree: hasRetainedRepairWorktree,
+            hasBaselineRef: hasRepairBaselineRef,
+            initialVerificationOutcome: initialVerificationDisposition.outcome,
+            providerGatesAlreadyPassed,
+            verificationUnavailable: initialVerificationDisposition.outcome === "not_run" && hasUnavailableVerificationGateEvidence(result),
+            hasMissingFileTargets,
+            isClarifyingNoOp,
+            providerExecutionSucceeded: result.success === true,
+            hasMaterializedDeliverable,
+            validationArtifactSatisfied,
+            filesChanged
+          });
+        }
+      );
+      result.repairAdmission = repairAdmission;
+      if (repairLoopConfig.enabled && result.repairAdmission.action === "skip" && (result.repairAdmission.reason === "skip_passing_gates" || result.repairAdmission.reason === "skip_clarifying_noop")) {
+        emitWarning(
+          "PERF-003",
+          {
+            taskId,
+            subsystem: "repair-loop",
+            executionPhase: "validation"
+          },
+          {
+            metadata: {
+              reason: result.repairAdmission.summary,
+              admissionReason: result.repairAdmission.reason
+            }
+          }
+        );
+      }
+      if (result.repairAdmission.action === "run") {
+        let repairOutcome = null;
+        let preRepairDiffSnapshot;
+        {
+          const worktreePath = result.retainedWorktreePath;
+          const baselineRef = result.baselineRef;
+          const initialCostUsd = result.costMetrics?.totalCost ?? result.result?.totalCostUsd ?? 0;
+          preRepairDiffSnapshot = await measurePostProviderPhase(
+            postProviderPhaseDurationsMs,
+            "preRepairDiffSnapshot",
+            verbose,
+            async () => captureRepairDiffSnapshot(worktreePath, baselineRef)
+          );
+          if (!preRepairDiffSnapshot) {
+            emitWarning(
+              "PERF-003",
+              {
+                taskId,
+                subsystem: "repair-loop",
+                executionPhase: "validation"
+              },
+              {
+                metadata: {
+                  reason: "pre-repair diff snapshot unavailable; repair-scope classification will be unknown",
+                  baselineRef,
+                  worktreePath
+                }
+              }
+            );
+          }
+          const repoRoot2 = process.cwd();
+          const cacheDir = verificationBaselineCacheDir();
+          const repairChangedFiles = await taskScopedChangedFiles(worktreePath, baselineRef);
+          const repairTestsProhibited = isTestRunProhibited(prompt);
+          const baselineForRepair = await measurePostProviderPhase(
+            postProviderPhaseDurationsMs,
+            "verificationBaselineCapture",
+            verbose,
+            async () => getOrCaptureVerificationBaseline({
+              repoRoot: repoRoot2,
+              baselineRef,
+              cacheDir,
+              captureOptions: {
+                changedFiles: repairChangedFiles,
+                skipTests: repairTestsProhibited
+              }
+            }).catch(() => null)
+          );
+          const baselineSucceeded = !!baselineForRepair?.metadata?.captureSucceeded;
+          const allowedFiles = (() => {
+            try {
+              const spec = parsePromptSpec(prompt);
+              return Array.isArray(spec.fileConstraint.targets) ? spec.fileConstraint.targets : [];
+            } catch {
+              return [];
+            }
+          })();
+          repairOutcome = await measurePostProviderPhase(
+            postProviderPhaseDurationsMs,
+            "repairLoop",
+            verbose,
+            async () => runVerificationDrivenRepairLoop({
+              config: {
+                enabled: true,
+                maxIterations: Math.max(1, Math.floor(repairLoopConfig.maxIterations)),
+                iterationTimeoutMs: Math.max(
+                  1e3,
+                  Math.floor(repairLoopConfig.iterationTimeoutMs)
+                ),
+                abortIfRegression: repairLoopConfig.abortIfRegression,
+                allowApiBreak: repairLoopConfig.allowApiBreak,
+                repairMode: repairLoopConfig.repairMode,
+                scopePolicy: repairLoopConfig.scopePolicy,
+                repairSaveModes: repairLoopConfig.repairSaveModes,
+                allowedFiles,
+                // Default to true for the software-aware Multi-Lens judge.
+                // This enables test failure detection in regression checks.
+                checkTestGate: !repairTestsProhibited,
+                skipTests: repairTestsProhibited
+              },
+              worktreePath,
+              baselineRef,
+              baseline: baselineSucceeded ? baselineForRepair : void 0,
+              taskId,
+              variantId: formatVariantIdentifier(variant),
+              originalPrompt: prompt,
+              initialCostUsd: Number.isFinite(initialCostUsd) && initialCostUsd > 0 ? initialCostUsd : 0,
+              executeRepair: async (repairPrompt, iterationIndex, abortSignal) => {
+                const repairTaskId = `${taskId}-verify-${iterationIndex + 1}`;
+                const repairVariant = {
+                  ...variant,
+                  // Enforce same worktree + prevent auto-commit drift during repair loops.
+                  workflowWorktreePath: worktreePath,
+                  disableAutoCommit: true,
+                  isBasicCompetition: true
+                };
+                const repairResult = await executor.executeVariant(
+                  repairTaskId,
+                  repairVariant,
+                  repairPrompt,
+                  { abortSignal }
+                );
+                const costUsd = repairResult.costMetrics?.totalCost ?? repairResult.result?.totalCostUsd ?? 0;
+                return { costUsd: Number.isFinite(costUsd) ? costUsd : 0 };
+              }
+            })
+          );
+          result.verification = repairOutcome.verification;
+          result.verificationLoop = repairOutcome.verificationLoop;
+        }
+        if (repairOutcome) {
+          const { verificationLoop } = repairOutcome;
+          const shouldPromoteRepairs = verificationLoop.iterations.length > 0 && verificationLoop.bestIterationPromotable;
+          if (!shouldPromoteRepairs) {
+          } else {
+            cleanupWorktreeAfterRun = false;
+            try {
+              const worktreePath = result.retainedWorktreePath;
+              const baselineRef = result.baselineRef;
+              const iterCount = verificationLoop.iterations.length;
+              let commitSucceeded = false;
+              const status = await measurePostProviderPhase(
+                postProviderPhaseDurationsMs,
+                "repairPromotionStatus",
+                verbose,
+                async () => execa3("git", ["status", "--porcelain"], {
+                  cwd: worktreePath,
+                  stdio: "pipe",
+                  reject: false
+                })
+              );
+              const isDirty = String(status.stdout ?? "").trim().length > 0;
+              const repairedSummary = await measurePostProviderPhase(
+                postProviderPhaseDurationsMs,
+                "repairPromotionChangeSummary",
+                verbose,
+                async () => getGitChangeSummary(worktreePath, baselineRef, true)
+              );
+              const finalDiffSnapshot = await measurePostProviderPhase(
+                postProviderPhaseDurationsMs,
+                "repairPromotionDiffSnapshot",
+                verbose,
+                async () => captureRepairDiffSnapshot(worktreePath, baselineRef)
+              );
+              if (!finalDiffSnapshot) {
+                emitWarning(
+                  "PERF-003",
+                  {
+                    taskId,
+                    subsystem: "repair-loop",
+                    executionPhase: "validation"
+                  },
+                  {
+                    metadata: {
+                      reason: "post-repair diff snapshot unavailable; repair-scope classification will be unknown",
+                      baselineRef,
+                      worktreePath
+                    }
+                  }
+                );
+              }
+              const repairScopeAnalysis = analyzeRepairScope({
+                preRepairDiff: preRepairDiffSnapshot,
+                finalDiff: finalDiffSnapshot
+              });
+              const repairPolicy = resolveRepairPromotionPolicy({
+                classification: repairScopeAnalysis.classification,
+                repairDelta: repairScopeAnalysis.repairDelta,
+                scopePolicy: repairLoopConfig.scopePolicy,
+                effectiveMode: repairPolicyCompletionMode(),
+                allowOffScopeRepair: isOffScopeRepairOverrideEnabled()
+              });
+              const allowRepairCommit = repairPolicy.action === "allow" || repairPolicy.action === "warn";
+              if (isDirty && !allowRepairCommit) {
+                emitWarning(
+                  "PERF-003",
+                  {
+                    taskId,
+                    subsystem: "repair-loop",
+                    executionPhase: "validation"
+                  },
+                  {
+                    metadata: {
+                      reason: `Skipped repair commit: ${repairPolicy.reason}`,
+                      policyAction: repairPolicy.action,
+                      classification: repairScopeAnalysis.classification,
+                      finalArtifactTrust: repairPolicy.finalArtifactTrust,
+                      worktreePath
+                    }
+                  }
+                );
+              } else if (isDirty) {
+                const stage = await measurePostProviderPhase(
+                  postProviderPhaseDurationsMs,
+                  "repairPromotionStage",
+                  verbose,
+                  async () => stageCommitEligibleChanges(worktreePath).then(
+                    (staged) => ({ staged, failure: void 0 }),
+                    (error) => ({
+                      staged: false,
+                      failure: error instanceof Error ? error.message : String(error)
+                    })
+                  )
+                );
+                if (stage.failure !== void 0 && verbose) {
+                  console.warn(
+                    chalk.yellow(
+                      `Failed to stage repairs (${stage.failure}); preserving worktree for manual commit.`
+                    )
+                  );
+                }
+                const isFullyClean = verificationLoop.passed;
+                const commitMsg = isFullyClean ? `fix: repair-loop (${iterCount} iterations) - all gates pass` : `fix: repair-loop (${iterCount} iterations) - no new regressions vs baseline`;
+                const commit = stage.staged ? await measurePostProviderPhase(
+                  postProviderPhaseDurationsMs,
+                  "repairPromotionCommit",
+                  verbose,
+                  async () => execa3("git", ["commit", "--no-verify", "-m", commitMsg], {
+                    cwd: worktreePath,
+                    stdio: "pipe",
+                    reject: false
+                  })
+                ) : void 0;
+                commitSucceeded = commit !== void 0 && (commit.exitCode ?? 0) === 0;
+                if (commit !== void 0 && (commit.exitCode ?? 0) !== 0 && verbose) {
+                  const output = String(commit.stdout ?? commit.stderr ?? "").trim();
+                  console.warn(
+                    chalk.yellow(
+                      `Failed to commit repairs (exit ${commit.exitCode ?? "unknown"}); preserving worktree for manual commit.${output ? `
+${output}` : ""}`
+                    )
+                  );
+                }
+              }
+              let restoredBaseline = false;
+              try {
+                const baseTree = await execGit(["rev-parse", `${baselineRef}^{tree}`], {
+                  cwd: worktreePath
+                });
+                restoredBaseline = baseTree.exitCode === 0 && await captureCurrentWorkspaceTreeIdentity(worktreePath) === String(baseTree.stdout).trim();
+              } catch {
+              }
+              result.repairOutcome = {
+                attempted: true,
+                passed: verificationLoop.passed,
+                passedBaseline: verificationLoop.passedBaseline,
+                iterations: verificationLoop.iterations.length,
+                stopReason: verificationLoop.stopReason,
+                filesChanged: repairedSummary.filesChanged,
+                committed: commitSucceeded,
+                repairTrigger: buildRepairTriggerEvidence(repairOutcome),
+                ...repairScopeAnalysis.preRepairDiff ? { preRepairDiff: repairScopeAnalysis.preRepairDiff } : {},
+                ...repairScopeAnalysis.finalDiff ? { finalDiff: repairScopeAnalysis.finalDiff } : {},
+                ...repairScopeAnalysis.repairDelta ? { repairDelta: repairScopeAnalysis.repairDelta } : {},
+                classification: repairScopeAnalysis.classification,
+                judgeVerdictApplicability: repairScopeAnalysis.judgeVerdictApplicability,
+                finalArtifactTrust: repairPolicy.finalArtifactTrust,
+                policy: repairPolicy
+              };
+              if (!restoredBaseline && repairedSummary.filesChanged > 0) {
+                result.gitMetrics = {
+                  filesChanged: repairedSummary.filesChanged,
+                  linesAdded: repairedSummary.linesAdded,
+                  linesDeleted: repairedSummary.linesRemoved,
+                  source: repairedSummary.source === "fallback" ? "unknown" : "worktree"
+                };
+              } else if (restoredBaseline) {
+                result.gitMetrics = {
+                  filesChanged: 0,
+                  linesAdded: 0,
+                  linesDeleted: 0,
+                  source: "worktree"
+                };
+                result.filesChanged = result.linesAdded = result.linesRemoved = 0;
+                result.emptyChanges = true;
+              }
+              if (!restoredBaseline && repairedSummary.filesChanged > 0)
+                result.emptyChanges = false;
+              if (repairedSummary.filesChanged > 0 || repairedSummary.source !== "fallback") {
+                const repairedDiff = normalizeWorktreeDiff(
+                  await captureWorktreeDiff(worktreePath, baselineRef, true)
+                );
+                if (repairedDiff || restoredBaseline) {
+                  result.worktreeDiff = repairedDiff;
+                }
+              }
+              if (verbose) {
+                const baselineStatus = verificationLoop.passed ? "all gates pass" : "no new regressions";
+                console.log(
+                  chalk.green(
+                    commitSucceeded ? `Verification repairs committed (${iterCount} iterations, ${repairedSummary.filesChanged} files, ${baselineStatus})` : `Verification repairs preserved (${iterCount} iterations, ${repairedSummary.filesChanged} files, ${baselineStatus})`
+                  )
+                );
+              }
+            } catch (commitError) {
+              if (verbose) {
+                const msg = commitError instanceof Error ? commitError.message : String(commitError);
+                console.warn(chalk.yellow(`Failed to commit repairs: ${msg}`));
+              }
+            }
+          }
+        }
+      }
+      if (result.gitMetrics && result.gitMetrics.filesChanged > 0) {
+        result.filesChanged = result.gitMetrics.filesChanged;
+        result.linesAdded = result.gitMetrics.linesAdded;
+        result.linesRemoved = result.gitMetrics.linesDeleted;
+      }
+      const workspaceEditsApplied = result.workspaceEditsApplied ?? 0;
+      if (result.gitMetrics && result.gitMetrics.filesChanged > 0 && (result.completeness ?? 0) === 0 && workspaceEditsApplied === 0) {
+        console.warn(
+          chalk.yellow(
+            "[Telemetry] Git shows changes but completeness is 0 and no workspace edits were applied."
+          ),
+          {
+            filesChanged: result.gitMetrics.filesChanged,
+            linesAdded: result.gitMetrics.linesAdded,
+            linesDeleted: result.gitMetrics.linesDeleted,
+            provider: variant.provider,
+            executionIntent: variant.executionIntent
+          }
+        );
+      }
+      await runFallbackVerification();
+      try {
+        await measurePostProviderPhase(
+          postProviderPhaseDurationsMs,
+          "baselineComparison",
+          verbose,
+          async () => attachBaselineComparisonIfAvailable(result)
+        );
+      } catch {
+      }
+      try {
+        await measurePostProviderPhase(
+          postProviderPhaseDurationsMs,
+          "registryDowngrade",
+          verbose,
+          async () => applyRegistryDowngradeIfApplicable(result)
+        );
+      } catch {
+      }
+      const repairedFiles = result.repairOutcome?.finalDiff?.files;
+      attachOffScopeConfigWarning(result, {
+        taskId,
+        prompt,
+        ...repairedFiles ? { changedPaths: repairedFiles } : {}
+      });
+      measurePostProviderPhaseSync(
+        postProviderPhaseDurationsMs,
+        "outcomeDerivation",
+        verbose,
+        () => {
+          result.outcome = deriveVariantOutcome(result);
+        }
+      );
+      if (specSignal) {
+        result.inputSpecWarning = {
+          completenessScore: specSignal.completenessScore,
+          guidanceTier: specSignal.guidanceTier,
+          missingFields: [...specSignal.missingFields],
+          hasFillPlaceholders: specSignal.hasFillPlaceholders
+        };
+      }
+      if (verbose) {
+        console.log(
+          chalk.green(`Execution completed in ${duration.toFixed(2)}s (success: ${result.success})`)
+        );
+        console.log(chalk.gray(`   ${formatVerboseWorkerCompletionMetric(result)}`));
+        if (specSignal) {
+          const missingNames = specSignal.missingFields.map(
+            (field) => FIELD_DISPLAY_NAMES[field] ?? field
+          );
+          console.log(
+            chalk.yellow(
+              `   Note: execution started from an incomplete spec (${Math.round(specSignal.completenessScore * 100)}% complete; missing: ${missingNames.join(", ")})`
+            )
+          );
+        }
+      }
+      if (telemetryEnabled && telemetry) {
+        try {
+          const processReliability = computeProcessReliabilityMetrics({
+            success: result.success,
+            result: result.result
+          });
+          let terminationReason;
+          if (result.terminationReason) {
+            terminationReason = result.terminationReason;
+          } else if (result.success) {
+            terminationReason = "completed";
+          } else if (result.timedOut) {
+            terminationReason = "timeout";
+          } else {
+            terminationReason = "failed_error";
+          }
+          telemetry.logVariantEvent(taskId, formatVariantIdentifier(variant), "completed", {
+            success: result.success,
+            completeness: result.completeness,
+            duration,
+            provider: variant.provider,
+            model: variant.model,
+            executionMode: variant.executionMode,
+            runMode,
+            executionIntent: variant.executionIntent,
+            behavioralMetrics: { processReliability },
+            terminationReason
+          });
+          telemetry.logVariantEvent(taskId, formatVariantIdentifier(variant), "evaluated", {
+            ...resolveVariantEvaluation(result),
+            completeness: result.completeness,
+            provider: variant.provider,
+            model: variant.model,
+            executionMode: variant.executionMode,
+            runMode,
+            executionIntent: variant.executionIntent
+          });
+          await measurePostProviderPhase(
+            postProviderPhaseDurationsMs,
+            "telemetryArtifactWrite",
+            verbose,
+            async () => {
+              const artifactResult = await telemetry.logVariantResultWithArtifact(
+                taskId,
+                formatVariantIdentifier(variant),
+                result,
+                {
+                  provider: variant.provider,
+                  model: variant.model,
+                  executionMode: variant.executionMode,
+                  runMode,
+                  executionIntent: variant.executionIntent
+                }
+              );
+              if (artifactResult?.success && artifactResult.manifestPath) {
+                result.artifactManifest = artifactResult.manifestPath;
+              }
+            }
+          );
+        } catch (_err) {
+          await warnOnce(
+            "Telemetry logging failed mid-run; disabling telemetry for this worker.",
+            telemetryWarning
+          );
+          telemetryEnabled = false;
+        }
+      }
+    } catch (error) {
+      const duration = Number(process.hrtime.bigint() - startTime) / 1e9;
+      const errorObj = error instanceof Error ? error : new Error(String(error));
+      result = {
+        variant: formatVariantIdentifier(variant),
+        provider: variant.provider,
+        model: variant.model,
+        executionMode: variant.executionMode,
+        success: false,
+        error: errorObj,
+        duration,
+        completeness: 0,
+        executionIntent: variant.executionIntent,
+        isBasicCompetition: variant.isBasicCompetition,
+        // Record requested prompt mode even on failure
+        promptModeRequested: variant.promptMode,
+        ...specSignal ? {
+          inputSpecWarning: {
+            completenessScore: specSignal.completenessScore,
+            guidanceTier: specSignal.guidanceTier,
+            missingFields: [...specSignal.missingFields],
+            hasFillPlaceholders: specSignal.hasFillPlaceholders
+          }
+        } : {}
+      };
+      const hostTerminationMetadata = hostTerminationMetadataFromUnknown(errorObj);
+      if (hostTerminationMetadata && classifyHostTermination(hostTerminationMetadata) === "timeout") {
+        result.timedOut = true;
+      }
+      const errorTerminationReason = result.terminationReason || (result.timedOut ? "timeout" : "failed_crash");
+      result.terminationReason = errorTerminationReason;
+      result.outcome = deriveVariantOutcome(result);
+      if (telemetryEnabled && telemetry) {
+        try {
+          const processReliability = computeProcessReliabilityMetrics({
+            success: false,
+            result: result.result
+          });
+          telemetry.logVariantEvent(taskId, formatVariantIdentifier(variant), "completed", {
+            success: false,
+            completeness: 0,
+            duration,
+            provider: variant.provider,
+            model: variant.model,
+            executionMode: variant.executionMode,
+            runMode,
+            executionIntent: variant.executionIntent,
+            behavioralMetrics: { processReliability },
+            terminationReason: errorTerminationReason
+          });
+          telemetry.logVariantEvent(taskId, formatVariantIdentifier(variant), "evaluated", {
+            verdict: "failure",
+            completeness: 0,
+            codeDelivered: false,
+            provider: variant.provider,
+            model: variant.model,
+            executionMode: variant.executionMode,
+            runMode,
+            executionIntent: variant.executionIntent
+          });
+          const artifactResult = await telemetry.logVariantResultWithArtifact(
+            taskId,
+            formatVariantIdentifier(variant),
+            result,
+            {
+              provider: variant.provider,
+              model: variant.model,
+              executionMode: variant.executionMode,
+              runMode,
+              executionIntent: variant.executionIntent
+            }
+          );
+          if (artifactResult?.success && artifactResult.manifestPath) {
+            result.artifactManifest = artifactResult.manifestPath;
+          }
+        } catch (_err) {
+          await warnOnce(
+            "Telemetry logging failed mid-run; disabling telemetry for this worker.",
+            telemetryWarning
+          );
+          telemetryEnabled = false;
+        }
+      }
+      if (verbose) {
+        console.error(chalk.red(`Execution failed: ${errorObj.message}`));
+        if (specSignal) {
+          const missingNames = specSignal.missingFields.map(
+            (field) => FIELD_DISPLAY_NAMES[field] ?? field
+          );
+          console.error(
+            chalk.yellow(
+              `   Note: execution started from an incomplete spec (${Math.round(specSignal.completenessScore * 100)}% complete; missing: ${missingNames.join(", ")})`
+            )
+          );
+        }
+      }
+    }
+    providerOutputForwarder.close();
+    if (!result.postProviderPhaseDurationsMs) {
+      result.postProviderPhaseDurationsMs = {};
+    }
+    const finalPostProviderPhaseDurationsMs = result.postProviderPhaseDurationsMs;
+    if (result.success === true && shouldDowngradeSuccessfulResultForShutdown({
+      shutdownRequested,
+      shutdownRequestedAtMs,
+      executionResultSettledAtMs
+    })) {
+      const signal = shutdownSignal ?? "SIGTERM";
+      result.success = false;
+      result.timedOut = signal === "SIGTERM";
+      result.terminationReason = signal === "SIGINT" ? "canceled_user" : "timeout";
+      result.error = buildShutdownAbortReason(signal);
+    }
+    measurePostProviderPhaseSync(
+      finalPostProviderPhaseDurationsMs,
+      "finalOutcomeDerivation",
+      verbose,
+      () => {
+        result.outcome = deriveVariantOutcome(result);
+      }
+    );
+    const worktreePathForCleanup = cleanupWorktreeAfterRun && result.success === true && typeof result.retainedWorktreePath === "string" ? result.retainedWorktreePath.trim() : void 0;
+    if (worktreePathForCleanup) {
+      result.retainedWorktreePath = void 0;
+    }
+    measurePostProviderPhaseSync(
+      finalPostProviderPhaseDurationsMs,
+      "resultFinalize",
+      verbose,
+      () => {
+        if (result.result) {
+          if (isNativeResearchEnabledFor(variant.provider)) {
+            const rawTranscript = `${result.result.rawStdout ?? ""}
+${result.result.rawStderr ?? ""}`;
+            if (rawTranscript.trim().length > 0) {
+              const scan = scanWebToolEvents(rawTranscript);
+              if (scan.corroboratedUrls.size > 0) {
+                result.result.researchCorroboratedUrls = Array.from(scan.corroboratedUrls);
+              }
+              if (scan.observedWebToolEvent) {
+                result.result.researchObservedWebToolEvent = true;
+              }
+            }
+          }
+          result.result.rawStdout = void 0;
+          result.result.rawStderr = void 0;
+          if (result.result.stdout && Buffer.byteLength(result.result.stdout, "utf8") > 2e5) {
+            result.result.stdout = truncateToByteLimit(result.result.stdout, 2e5);
+          }
+          if (result.result.stderr && Buffer.byteLength(result.result.stderr, "utf8") > 2e5) {
+            result.result.stderr = truncateToByteLimit(result.result.stderr, 2e5);
+          }
+        }
+      }
+    );
+    sanitizeVariantResult(result);
+    try {
+      await measurePostProviderPhase(
+        finalPostProviderPhaseDurationsMs,
+        "resultWrite",
+        verbose,
+        async () => writeResultFileAtomically(resultFile, result)
+      );
+      emitWorkerLifecycleMarker(RESULT_WRITTEN_MARKER_PREFIX, elapsedMsSince(startTime));
+      emitWorkerLifecycleMarker(
+        POST_PROVIDER_PHASES_MARKER_PREFIX,
+        finalPostProviderPhaseDurationsMs
+      );
+      if (verbose) {
+        console.log(chalk.green(`Result written to ${resultFile}`));
+      }
+      if (telemetryEnabled && telemetry) {
+        try {
+          TelemetryLogger.disposeShared();
+        } catch (_err) {
+        }
+      }
+      if (worktreePathForCleanup && worktreePathForCleanup.length > 0) {
+        await measurePostProviderPhase(
+          finalPostProviderPhaseDurationsMs,
+          "cleanup",
+          verbose,
+          async () => tryCleanupRetainedWorktree(worktreePathForCleanup, verbose)
+        );
+      }
+      applyWorkerEnvOverrides({
+        BUILD_RETAIN_BASIC_WORKTREE: prevRetainBasicWorktree
+      });
+      emitWorkerLifecycleMarker(CLEANUP_START_MARKER_PREFIX, elapsedMsSince(startTime));
+      await measurePostProviderPhase(
+        finalPostProviderPhaseDurationsMs,
+        "cleanup",
+        verbose,
+        async () => signalCoordinator.runCleanupHandlers("variant-worker exit", {
+          timeoutMs: SIGNAL_CLEANUP_TIMEOUT_MS
+        })
+      );
+      emitWorkerLifecycleMarker(CLEANUP_COMPLETE_MARKER_PREFIX, elapsedMsSince(startTime));
+      emitWorkerLifecycleMarker(
+        POST_PROVIDER_PHASES_MARKER_PREFIX,
+        finalPostProviderPhaseDurationsMs
+      );
+      emitWorkerLifecycleMarker(ACTIVE_HANDLES_MARKER_PREFIX, activeHandleSummary());
+      if (preserveWorktreesForDebug) {
+        applyWorkerEnvOverrides({
+          BUILD_PRESERVE_WORKTREES: prevPreserveWorktrees
+        });
+      }
+      return;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(chalk.red(`Failed to write result: ${message}`));
+      if (telemetryEnabled && telemetry) {
+        try {
+          TelemetryLogger.disposeShared();
+        } catch (_err) {
+        }
+      }
+      applyWorkerEnvOverrides({
+        BUILD_RETAIN_BASIC_WORKTREE: prevRetainBasicWorktree
+      });
+      await signalCoordinator.runCleanupHandlers("variant-worker fatal-exit", {
+        timeoutMs: SIGNAL_CLEANUP_TIMEOUT_MS
+      });
+      if (preserveWorktreesForDebug) {
+        applyWorkerEnvOverrides({
+          BUILD_PRESERVE_WORKTREES: prevPreserveWorktrees
+        });
+      }
+      throw new ExitCodeError(1, message);
+    }
+  } finally {
+    uninstallPostProviderSignalHandlers();
+    signalCoordinator.unregister(signalHandlerName);
+    signalCoordinator.unregister(processLifecycleSignalHandlerName);
+    setProcessLifecycleManager(void 0);
+  }
+}
+var workerEntrypoint = fileURLToPath(import.meta.url);
+var invokedScript = process.argv[1] ? path2.resolve(process.argv[1]) : null;
+var isDirectInvocation = invokedScript !== null && path2.resolve(workerEntrypoint) === invokedScript;
+async function runVariantWorkerEntrypoint(entryOptions = {}) {
+  if (!entryOptions.runtimeAlreadyChecked) {
+    assertBuildRuntimeReady({ command: "variant-worker" });
+  }
+  try {
+    await main();
+    return 0;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(chalk.red(`Unhandled error: ${message}`));
+    try {
+      const argv = process.argv;
+      const flagIdx = argv.indexOf("--result-file");
+      const resultFile = flagIdx !== -1 && flagIdx + 1 < argv.length ? argv[flagIdx + 1] : void 0;
+      if (resultFile) {
+        const payload = {
+          success: false,
+          error: { message, stage: "bootstrap" },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await writeResultFileAtomically(resultFile, payload);
+      }
+    } catch {
+    }
+    return error instanceof ExitCodeError ? error.exitCode : 1;
+  }
+}
+if (process.env.VITEST !== "1" && isDirectInvocation) {
+  runVariantWorkerEntrypoint().then((exitCode) => {
+    if (exitCode === 0) {
+      process.exitCode = 0;
+    } else {
+      process.exit(exitCode);
+    }
+  }).catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(1);
+  });
+}
+export {
+  __testOnlyWriteResultFileAtomically,
+  attachBaselineComparisonIfAvailable,
+  buildRepairTriggerEvidence,
+  buildShutdownAbortReason,
+  createProviderOutputForwarder,
+  decideRepairAdmission,
+  executeWorker,
+  extractOriginalPrompt,
+  findVariantWorktreePathForTimeout,
+  formatVerboseWorkerCompletionMetric,
+  initializeWorkerExecutionContext,
+  isValidationArtifactOnlyPrompt,
+  resolveInitialVerificationDisposition,
+  resolveRepairPromotionPolicy,
+  runVariantWorkerEntrypoint,
+  serializeErrorForJson,
+  shouldDowngradeSuccessfulResultForShutdown,
+  shouldTrustVerificationLoopBaseline,
+  tryCleanupRetainedWorktree
+};
+//# sourceMappingURL=variant-worker-COB5YTJX.js.map