@ebrindley/build 0.0.0-stage → 2026.11.14-rc.1

package/dist/worker-WIWN62MC.js

@@ -0,0 +1,1504 @@
+import {
+  buildJudgeCompletenessTelemetryFromVariants,
+  loadConfiguredConcurrency,
+  mergeJudgeEvaluatedVariantSignals,
+  parseDeliverableContract,
+  parseProviderLimits,
+  persistJudgeResults,
+  persistNativeResearchTraces,
+  resolveJudgeRequestedLabel,
+  resolvePersistedJudgeRunState,
+  resolveWinnerVerifiedForDecision,
+  shouldStopBeforeJudgeOrSynthesis
+} from "./chunk-RACDQC7S.js";
+import {
+  parseNativeResearchProviders
+} from "./chunk-OSK7QWPD.js";
+import {
+  buildCompetitionDecisionTelemetry,
+  finalizeInterruptedEvaluationHandle,
+  inferCompetitionFinalOutcome,
+  isVerifiedVariantForGatePolicy,
+  persistCompeteBacklogProvenance,
+  resolveCompeteBacklogSuccessOutcome,
+  resolveCompetitionJudgeWinner,
+  resolveRunSummaryPrimaryJudge,
+  toHandleWinnerMetadata
+} from "./chunk-Q7ADHWBE.js";
+import "./chunk-3PL22IYZ.js";
+import {
+  judgeForceModelOption
+} from "./chunk-AY3MHEFM.js";
+import {
+  startDetachedWorkerRegistryHeartbeat
+} from "./chunk-P7RVCHQV.js";
+import "./chunk-XPVNGHPF.js";
+import "./chunk-3S2R4XJI.js";
+import "./chunk-YYTOA6DP.js";
+import "./chunk-H3S2VHTT.js";
+import "./chunk-EO5UROKQ.js";
+import {
+  attemptSynthesisWithGateValidation,
+  backfillMasterFinalVariantTelemetry,
+  buildWinnerVerification,
+  cleanupSynthesisInputPatches,
+  persistSynthesisDeliveryVariant,
+  resolveProviderConcurrencyOverrides,
+  resolveSynthesisInputPatchDir,
+  runBasicCompetition,
+  selectWinnerWithJudge,
+  shouldRunCompetitionSynthesis,
+  throwIfBasicCompetitionGloballyTimedOut
+} from "./chunk-VKBDYZ4I.js";
+import "./chunk-BDYUPPEZ.js";
+import {
+  createEvaluationHandleFinalState,
+  finalizeEvaluationHandle,
+  isDurableHandleCompletion,
+  updateEvaluationHandleWithResult,
+  updateEvaluationHandleWithSynthesisResult
+} from "./chunk-JQ5ENKLV.js";
+import "./chunk-PNFTPNSR.js";
+import "./chunk-DAS7J3JW.js";
+import "./chunk-WEW7UFWE.js";
+import "./chunk-LULOGMMM.js";
+import "./chunk-QILAQACE.js";
+import "./chunk-LS3G3OE4.js";
+import "./chunk-BTKKMYOG.js";
+import "./chunk-S6GZSVSF.js";
+import "./chunk-77I6G4CO.js";
+import "./chunk-NEQUQHOX.js";
+import "./chunk-DJG5RIOR.js";
+import "./chunk-ZWJVJRAJ.js";
+import "./chunk-A5A5QAUX.js";
+import "./chunk-JQUMSIGC.js";
+import "./chunk-ZL6E4HMY.js";
+import "./chunk-2OUAEH67.js";
+import "./chunk-H4HXVWEC.js";
+import "./chunk-WPKLYOAM.js";
+import "./chunk-BZRLSZNV.js";
+import "./chunk-GM74HUBM.js";
+import "./chunk-2L36U25O.js";
+import "./chunk-CA6GSDIV.js";
+import "./chunk-BQ3VAGXH.js";
+import "./chunk-GT6HFKJB.js";
+import "./chunk-3HW3BM6X.js";
+import "./chunk-VLMDM56Q.js";
+import "./chunk-7HP2GFH2.js";
+import "./chunk-VKKRXOFE.js";
+import "./chunk-BF4WFISU.js";
+import "./chunk-ZUQOHGNF.js";
+import "./chunk-V3WDLXPF.js";
+import {
+  buildTerminalCompetitionDeliveryRecord,
+  finalizeVariantVerification,
+  resolveRequiredGatePolicyForPhase
+} from "./chunk-B7KDXQGO.js";
+import "./chunk-W6XSZKRH.js";
+import "./chunk-L2PIVBOV.js";
+import "./chunk-5YDE3Q62.js";
+import "./chunk-3NGHELNE.js";
+import "./chunk-7TUTZTI2.js";
+import "./chunk-ONWEOPI3.js";
+import "./chunk-HHWDTB6S.js";
+import "./chunk-VKRGWY72.js";
+import "./chunk-5XTL67ZG.js";
+import "./chunk-XMFW7H67.js";
+import "./chunk-GOSY2TKK.js";
+import "./chunk-IYY3HQAD.js";
+import "./chunk-HZYKRLN3.js";
+import "./chunk-PVJBTI7P.js";
+import "./chunk-ZZ44KOJE.js";
+import "./chunk-UKMPASIC.js";
+import "./chunk-5PRWELNO.js";
+import "./chunk-LPQ7NZEN.js";
+import "./chunk-TGCVL74Y.js";
+import "./chunk-QXBKIHY7.js";
+import "./chunk-Q3DHEZA5.js";
+import "./chunk-76A74QWN.js";
+import "./chunk-4EJKQIW2.js";
+import "./chunk-L32WD57F.js";
+import "./chunk-6DBMALXL.js";
+import "./chunk-MKASIKWZ.js";
+import "./chunk-UDNNAQN5.js";
+import "./chunk-T7AV45DV.js";
+import "./chunk-HKO45NLZ.js";
+import "./chunk-ABMN3UEO.js";
+import "./chunk-3IP5I32P.js";
+import "./chunk-5HCN4JO5.js";
+import "./chunk-WGTFA6SF.js";
+import "./chunk-LDJCKAJP.js";
+import {
+  ProcessRegistry
+} from "./chunk-QP5ST7RI.js";
+import "./chunk-FY6Y4Z2F.js";
+import "./chunk-HS3SY6HN.js";
+import "./chunk-ENYRCL43.js";
+import "./chunk-FDI23B6R.js";
+import "./chunk-Z7CDQNH3.js";
+import "./chunk-PRDHI2L5.js";
+import "./chunk-T5KLCNR7.js";
+import "./chunk-JVHGMURQ.js";
+import "./chunk-NY7VYMMY.js";
+import "./chunk-T42WJJZC.js";
+import "./chunk-B7PYTV72.js";
+import "./chunk-4QKP6I4C.js";
+import "./chunk-GWHGTG37.js";
+import "./chunk-P3UARDCT.js";
+import "./chunk-GQXLXRFA.js";
+import "./chunk-3UBZI5DW.js";
+import "./chunk-BDPYFAB4.js";
+import "./chunk-RNI2GUIF.js";
+import "./chunk-CE5OZBYY.js";
+import "./chunk-3WY5TU2O.js";
+import "./chunk-ATLM7JIT.js";
+import "./chunk-XON4ZCYX.js";
+import "./chunk-PPHXX4W7.js";
+import "./chunk-5AW4RMNG.js";
+import {
+  ExitCodeError
+} from "./chunk-Y4ZDDHB6.js";
+import "./chunk-WKFOJ5ZG.js";
+import "./chunk-PTDYGMC7.js";
+import "./chunk-SVNCLR45.js";
+import "./chunk-5F43TUIN.js";
+import "./chunk-RI4EX2QE.js";
+import "./chunk-ETA2K4KI.js";
+import "./chunk-CRPRVNQ4.js";
+import "./chunk-KQ4NGOJI.js";
+import "./chunk-TMBDRHAX.js";
+import "./chunk-RVMOOPSL.js";
+import "./chunk-4UMRUFBD.js";
+import "./chunk-3M57DADF.js";
+import "./chunk-RGXSKAPL.js";
+import "./chunk-T7UY44GG.js";
+import "./chunk-GD5U6MD4.js";
+import "./chunk-7RMARDVH.js";
+import "./chunk-APKT7ARR.js";
+import "./chunk-ZMLOC3DW.js";
+import "./chunk-FIEUSGNJ.js";
+import "./chunk-WEIUS5NT.js";
+import "./chunk-KQYQOXMS.js";
+import "./chunk-S47ISY27.js";
+import "./chunk-JMJYHBIQ.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-DYET2NYJ.js";
+import "./chunk-MYLH2S4G.js";
+import "./chunk-3P5IN5E7.js";
+import "./chunk-CBZHP756.js";
+import "./chunk-WEI3ZDZH.js";
+import "./chunk-H6MJGKAW.js";
+import "./chunk-67YRJPJO.js";
+import "./chunk-SZAJAHLF.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-DD4FGKKB.js";
+import "./chunk-M43JKX7J.js";
+import "./chunk-SDPIFNLD.js";
+import "./chunk-GO6DRECI.js";
+import "./chunk-5WV5L5XS.js";
+import "./chunk-QWMQ74KD.js";
+import "./chunk-GAFJEYLK.js";
+import "./chunk-YKC75XK4.js";
+import "./chunk-T7E5JS6N.js";
+import "./chunk-ZJB6SQPA.js";
+import "./chunk-QTBZFXYZ.js";
+import {
+  signalCoordinator
+} from "./chunk-GC4CRMTS.js";
+import "./chunk-P7CQGPLS.js";
+import "./chunk-E2BWHHGS.js";
+import "./chunk-IVZEONFC.js";
+import "./chunk-M2D3JXGN.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-DP3RIHLU.js";
+import {
+  formatVariantIdentifier
+} from "./chunk-DFDPRCSF.js";
+import "./chunk-D2M2Y5ID.js";
+import "./chunk-UJP3XM54.js";
+import "./chunk-MULMXX4V.js";
+import "./chunk-UTDEOPKV.js";
+import {
+  atomicWriteJson
+} from "./chunk-RFDVSI4N.js";
+import "./chunk-M4BUEXXF.js";
+import "./chunk-ZH4G3FU5.js";
+import "./chunk-726G6WDL.js";
+import "./chunk-2C2AZO23.js";
+import "./chunk-5UBIFVRD.js";
+import "./chunk-3AMLRT2B.js";
+import "./chunk-CE4O646H.js";
+import "./chunk-YVCMDVBB.js";
+import "./chunk-7HPCIOMA.js";
+import {
+  parseJsonWithContext
+} from "./chunk-P6SSWAKY.js";
+import "./chunk-ETAD4NKD.js";
+import "./chunk-NZ4AOB7R.js";
+import "./chunk-7YAOUUKK.js";
+import "./chunk-XYL6WTBK.js";
+import "./chunk-O5X6BKAO.js";
+import "./chunk-R2CKS6WT.js";
+import {
+  deriveVariantOutcome
+} from "./chunk-YYQJK6RH.js";
+import "./chunk-EPRMH6HO.js";
+import "./chunk-XHOI4V62.js";
+import {
+  assertSafePathComponent
+} from "./chunk-S2VQCZO4.js";
+import "./chunk-6TBEX4R4.js";
+import "./chunk-PXKERBKX.js";
+import "./chunk-QYQOVOLR.js";
+import "./chunk-QFLBRWCJ.js";
+import "./chunk-SFY5MOZC.js";
+import "./chunk-SVUNZOPG.js";
+import "./chunk-SGSZXSWM.js";
+import "./chunk-R2TIYG7U.js";
+import "./chunk-5FKHIKTS.js";
+import "./chunk-LR3SKBM4.js";
+import "./chunk-XJ2E7YEJ.js";
+import "./chunk-O4XNVUL6.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 "./chunk-YO5BAJ55.js";
+import "./chunk-CTAFIG47.js";
+import "./chunk-D6WTZMZB.js";
+import "./chunk-5EQN56OZ.js";
+import "./chunk-RBBTBCHX.js";
+import "./chunk-4DJL2VXA.js";
+import "./chunk-62NR3IQM.js";
+import "./chunk-TUQMMFEQ.js";
+import "./chunk-EPAMVGI3.js";
+import "./chunk-6CB3KJRY.js";
+import "./chunk-L2S235CU.js";
+import "./chunk-D4VJFCGZ.js";
+import "./chunk-RPIMAMV7.js";
+import "./chunk-ALDTFNZ3.js";
+import "./chunk-QOIASNEJ.js";
+import "./chunk-2VUEDIUM.js";
+import "./chunk-MJ6WNSIX.js";
+import "./chunk-5KQETTNS.js";
+import "./chunk-J2ICMYDA.js";
+import "./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 {
+  LabPathResolver
+} from "./chunk-C3KCMAJP.js";
+import "./chunk-FKCG7K6H.js";
+import {
+  resolveRunStateDir
+} from "./chunk-AJN5Y5YZ.js";
+import "./chunk-MHLEZQQI.js";
+import "./chunk-HEP3ILP4.js";
+import "./chunk-BQJOGAWT.js";
+import "./chunk-WV3KQDPE.js";
+import "./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 "./chunk-RRC5BL7B.js";
+import "./chunk-352PCJLK.js";
+import "./chunk-RCP2Y6DQ.js";
+import "./chunk-M6UHOC4I.js";
+import "./chunk-LRGH3CCV.js";
+import "./chunk-BV3XQQLU.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 "./chunk-I56TH7VM.js";
+import "./chunk-Z5WGNULV.js";
+import "./chunk-O26L6F7F.js";
+import "./chunk-RJ6RSNT6.js";
+import {
+  assertBuildRuntimeReady
+} from "./chunk-ZR3DRTPS.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_RESEARCH_NATIVE_PROVIDERS,
+  createExecutionContext,
+  debugLog,
+  getExecutionContext,
+  readEnv,
+  resolveBuildDirFromContext,
+  resolveCliRepoRoot,
+  setExecutionContext
+} from "./chunk-7VRJHTGZ.js";
+import "./chunk-XDM65LBX.js";
+import {
+  sanitizeString
+} from "./chunk-CPSVQR2I.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/cli/worker.ts
+import { mkdir, readFile, unlink } from "fs/promises";
+import path from "path";
+import { pathToFileURL } from "url";
+import { Command } from "commander";
+
+// src/cli/handlers/compete/background-finalization.ts
+function readBackgroundRunMetadata(value) {
+  if (value === void 0) return void 0;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Worker run metadata must be an object");
+  }
+  const metadata = value;
+  if (metadata.runSemantics !== void 0 && !["competition", "fusion", "analysis"].includes(metadata.runSemantics)) {
+    throw new Error("Worker run metadata has invalid run semantics");
+  }
+  const replay = metadata.replay;
+  if (replay !== void 0 && (!replay || typeof replay !== "object" || Array.isArray(replay) || [replay.command, replay.taskLabel, replay.executionIntent].some(
+    (item) => item !== void 0 && typeof item !== "string"
+  ) || replay.argv !== void 0 && (!Array.isArray(replay.argv) || replay.argv.some((item) => typeof item !== "string")))) {
+    throw new Error("Worker run metadata has invalid replay data");
+  }
+  return { runSemantics: metadata.runSemantics, replay };
+}
+function finalizeWorkerWinner(taskId, result, options2 = {}) {
+  const winnerMetadata = toHandleWinnerMetadata(result.winner);
+  const inferredOutcome = inferCompetitionFinalOutcome(result);
+  const requiredGatePolicy = options2.requiredGatePolicy ?? "all";
+  const executionIntent = options2.runMetadata?.replay?.executionIntent ?? result.winner?.executionIntent ?? (result.winner?.testsExecuted?.skipReason === "analysis-intent" ? "analysis" : void 0);
+  const decisionTelemetry = buildCompetitionDecisionTelemetry({
+    winner: result.winner,
+    winnerVerified: resolveWinnerVerifiedForDecision({
+      winner: result.winner,
+      verifiedVariants: result.variants.filter(
+        (variant) => isVerifiedVariantForGatePolicy(variant, requiredGatePolicy)
+      ),
+      verificationApplicable: executionIntent !== "analysis",
+      requiredGatePolicy
+    }),
+    latestDecision: options2.latestDecision ?? (options2.judgeError ? {
+      winnerDeclared: false,
+      reason: options2.judgeError,
+      decisionOutcome: "unavailable",
+      judgeFailures: [
+        { judgeType: options2.aiJudgePrimary ?? "ai", reason: options2.judgeError }
+      ]
+    } : void 0),
+    primaryJudge: resolveRunSummaryPrimaryJudge(options2.aiJudgePrimary, result.winner)
+  });
+  const judgeState = resolvePersistedJudgeRunState({
+    isFusionRun: false,
+    judgeOff: options2.judgeOff === true,
+    aiJudgeRequested: options2.aiJudgeRequested === true,
+    decisionOutcome: decisionTelemetry.decision.outcome,
+    decisionReason: options2.judgeError ?? decisionTelemetry.decision.reason,
+    winnerSelectionSource: result.winner?.winnerSelectionSource,
+    winnerSelectionReason: result.winner?.winnerSelectionReason
+  });
+  const common = {
+    ...!options2.judgeOff ? decisionTelemetry : {},
+    runMetadata: {
+      ...options2.runMetadata,
+      runSemantics: options2.runMetadata?.runSemantics ?? "competition",
+      judge: {
+        requested: resolveJudgeRequestedLabel({
+          effectiveJudge: options2.judgeOff ? "off" : void 0,
+          aiJudgeRequested: options2.aiJudgeRequested === true,
+          aiJudgePrimary: options2.aiJudgePrimary
+        }),
+        ...judgeState
+      }
+    },
+    winnerVerification: result.winnerVerification,
+    completenessTelemetry: buildJudgeCompletenessTelemetryFromVariants(result.variants),
+    // Which artifact this run selected for delivery. Without it a later
+    // `compete apply` resolves the judge winner and silently omits a validated
+    // synthesis artifact the run selected.
+    delivery: buildTerminalCompetitionDeliveryRecord({
+      winner: result.winner,
+      synthesisDeliveryVariant: result.synthesisDeliveryVariant
+    })
+  };
+  const finalState = options2.judgeOff ? createEvaluationHandleFinalState({
+    ...common,
+    outcome: "no_winner",
+    winner: null,
+    decision: {
+      outcome: "none",
+      reason: "judge_off",
+      decisionStatus: "not_run",
+      decisionOutcome: "no_judge",
+      primaryJudge: "n/a"
+    }
+  }) : inferredOutcome === "winner_selected" && winnerMetadata ? createEvaluationHandleFinalState({
+    ...common,
+    outcome: "winner_selected",
+    winner: winnerMetadata
+  }) : inferredOutcome === "timed_out" ? createEvaluationHandleFinalState({
+    ...common,
+    outcome: "timed_out",
+    winner: null,
+    errorMessage: "Competition ended with timed_out"
+  }) : createEvaluationHandleFinalState({
+    ...common,
+    outcome: inferredOutcome === "all_failed" ? "all_failed" : "no_winner",
+    winner: null
+  });
+  const finalizeResult = finalizeEvaluationHandle(taskId, finalState);
+  if (finalizeResult.kind === "persistence_failed") {
+    console.warn(
+      `[Worker ${process.pid}] Failed to finalize authoritative winner: ${finalizeResult.error}`
+    );
+  } else if (finalizeResult.kind === "absent") {
+    if (options2.requireHandle) {
+      console.warn(
+        `[Worker ${process.pid}] Required evaluation handle absent during authoritative finalize`
+      );
+    }
+  } else if (finalizeResult.kind === "not_terminal") {
+    console.warn(
+      `[Worker ${process.pid}] Evaluation handle still running (active candidates); authoritative finalize deferred`
+    );
+  }
+  return finalizeResult;
+}
+
+// src/cli/handlers/compete/background-judge-winner.ts
+function resolveBackgroundJudgeWinner(input) {
+  mergeJudgeEvaluatedVariantSignals(input.variants, input.evaluatedVariants);
+  if (!input.judgedWinner) return null;
+  return resolveCompetitionJudgeWinner(
+    input.variants,
+    input.judgedWinner,
+    resolveRequiredGatePolicyForPhase(input.prompt, "post-judge")
+  ).winner;
+}
+
+// src/cli/worker.ts
+function shouldPromoteBackgroundSynthesisDelivery(input) {
+  if (!input.synthesisVariant) return false;
+  if (input.synthesisApplied !== true) return false;
+  if (input.gatesPassed !== true) return false;
+  const strategy = input.strategy ?? "agentic-synthesis";
+  return strategy === "agentic-synthesis" || input.complementaryPatchApplied === true;
+}
+async function persistBackgroundSynthesisDeliveryVariant(options2) {
+  return persistSynthesisDeliveryVariant({
+    ...options2,
+    backfillTelemetry: (variant) => backfillMasterFinalVariantTelemetry(options2.taskId, variant, {
+      buildDir: options2.buildDir
+    })
+  });
+}
+var program = new Command();
+var WORKER_REGISTRY_HEARTBEAT_MS = 6e4;
+var BACKGROUND_WORKER_FINAL_CLEANUP_TIMEOUT_MS = 15e3;
+program.requiredOption("--task-id <id>", "Task ID").option("--backlog-item <id>", "Backlog item ID associated with this background compete run").option(
+  "--config-file <path>",
+  "Path to config JSON file containing {prompt, variants} (preferred)"
+).option("--prompt <prompt>", "Task prompt (legacy; requires --variants too)").option("--variants <variants>", "Variants JSON (legacy; requires --prompt too)").option("--timeout <ms>", "Timeout in milliseconds").option("--executor-timeout-minutes <minutes>", "Per-variant executor timeout in minutes").option(
+  "--max-concurrent <n>",
+  "Maximum concurrent variant executions (threaded from the foreground compete flag)",
+  (value) => Number.parseInt(value, 10)
+).option(
+  "--provider-limit <limit>",
+  "Per-provider concurrency limit provider=N (repeatable; threaded from the foreground compete flag)",
+  (value, previous) => [...previous, value],
+  []
+).option("--verbose", "Verbose output").option("--ai-judge", "Use AI judge").option("--judge-off", "Disable automatic winner selection for multi-variant comparison").option("--ai-judge-model <model>", "AI judge model").option("--ai-judge-verbose", "AI judge verbose output").option("--ai-judge-show-rationale", "Show AI judge rationale").option("--ai-judge-verbosity <level>", "AI judge verbosity level").option("--ai-judge-min-score <score>", "AI judge minimum score", parseFloat).option(
+  "--ai-judge-confidence-threshold <threshold>",
+  "AI judge confidence threshold",
+  parseFloat
+).option("--ai-judge-streaming", "Enable AI judge streaming").option("--ai-judge-telemetry", "Enable AI judge telemetry").option("--judge-run [judges]", "Run one or more judges: ai,multi-lens (no value = ai only)").option("--judge-primary <judge>", "Primary judge for winner selection when multiple judges run").option(
+  "--judge-models <models>",
+  "Judge model plan: a registered judge-capable provider. Deprecated aliases: claude, codex."
+).option(
+  "--judge-model <role=provider:model>",
+  "Scoped judge model override: ai, multi-lens, parent, or worker",
+  (value, previous = []) => [...previous, value],
+  []
+).addOption(judgeForceModelOption(program)).option("--judge-strict", "Strict judge mode: one judge attempt without retries or reruns").option(
+  "--synthesize",
+  "Enable synthesis when multiple edit/code variants produce a winner; use --no-synthesize to disable"
+).option("--no-synthesize", "Disable synthesis of top-N variants").option("--synthesis-top-n <n>", "Number of top variants to synthesize", parseInt).option(
+  "--synthesis-strategy <strategy>",
+  "Synthesis strategy (agentic-synthesis default or cherry-pick experimental deterministic mode)"
+).option("--synthesis-model <model>", "Model for synthesis generation").option("--create-pr", "Create PR for winning variant").option("--verification-mode <mode>", "Verification mode (auto|touched|full|off)").option("--anonymize-judge", "Anonymize judge evaluation").option("--no-anonymize-judge", "Disable anonymous judge labels").option("--preserve-worktrees", "Preserve worktrees after execution").option("--no-preserve-worktrees", "Remove worktrees after execution, even for one variant").option(
+  "--judge-profile <profile>",
+  "Judge profile (best-as-delivered|acceptance-ready|best-foundation; alias: merge-ready\u2192acceptance-ready)"
+).option("--cost-metrics", "Show cost metrics");
+function resolveWorkerAnonymizeJudge(workerOptions) {
+  if (workerOptions.anonymizeJudge === false || workerOptions.noAnonymizeJudge === true) {
+    return false;
+  }
+  if (workerOptions.anonymizeJudge === true) {
+    return true;
+  }
+  return void 0;
+}
+var options;
+function sanitizeBackgroundDiagnosticEntries(entries) {
+  return entries?.map((entry) => sanitizeString(entry));
+}
+function buildBackgroundWorkerVariantHealthState(variant) {
+  const diagnostics = variant.providerDiagnostics;
+  return {
+    providerDiagnostics: diagnostics ? {
+      finalAnswerPresent: diagnostics.finalAnswerPresent,
+      terminalResultPresent: diagnostics.terminalResultPresent,
+      toolErrors: sanitizeBackgroundDiagnosticEntries(diagnostics.toolErrors),
+      authErrors: sanitizeBackgroundDiagnosticEntries(diagnostics.authErrors),
+      transportErrors: sanitizeBackgroundDiagnosticEntries(diagnostics.transportErrors),
+      retryErrors: sanitizeBackgroundDiagnosticEntries(diagnostics.retryErrors),
+      stderrSeverity: diagnostics.stderrSeverity
+    } : void 0,
+    authError: variant.authError ? {
+      provider: sanitizeString(variant.authError.provider),
+      message: sanitizeString(variant.authError.message)
+    } : void 0
+  };
+}
+function getBackgroundStatePath(taskId) {
+  const safeTaskId = assertSafePathComponent(taskId, "taskId");
+  return path.join(
+    resolveRunStateDir(resolveBuildDirFromContext()),
+    "background",
+    `${safeTaskId}.json`
+  );
+}
+async function persistFatalBootstrapFailure(taskId, fatalError) {
+  const failedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const errorMessage = sanitizeString(
+    fatalError instanceof Error ? fatalError.message : String(fatalError)
+  );
+  try {
+    const statePath = getBackgroundStatePath(taskId);
+    await mkdir(path.dirname(statePath), { recursive: true });
+    await atomicWriteJson(statePath, {
+      taskId,
+      pid: process.pid,
+      status: "failed",
+      failedAt,
+      activePhase: "startup",
+      elapsedMs: 0,
+      orchestratorTimeoutObserved: false,
+      terminationSource: "exception",
+      error: errorMessage
+    });
+  } catch {
+  }
+  try {
+    finalizeEvaluationHandle(
+      taskId,
+      createEvaluationHandleFinalState({
+        outcome: "error",
+        completedAt: failedAt,
+        errorMessage,
+        winner: null
+      })
+    );
+  } catch (finalizeError) {
+    console.error(
+      `[Worker ${process.pid}] Failed to finalize evaluation handle on fatal bootstrap error:`,
+      finalizeError
+    );
+  }
+  try {
+    const registry = new ProcessRegistry({ verbose: false });
+    await registry.init();
+    await registry.unregister(process.pid);
+  } catch {
+  }
+}
+function summarizeVariants(variants) {
+  return variants.map((variant) => ({
+    provider: variant.provider,
+    model: variant.model,
+    executionMode: variant.executionMode,
+    variant: formatVariantIdentifier(variant)
+  }));
+}
+function isOrchestratorTimeoutError(error) {
+  return error instanceof Error && ("code" in error && error.code === "COMPETITION_TIMEOUT" || /Orchestrator timeout after .* minutes/i.test(error.message));
+}
+function resolveBackgroundBasicJudgeState(options2) {
+  const judgeOff = options2.judgeOff === true;
+  return {
+    judgeOff,
+    aiJudgeRequested: !judgeOff && (options2.aiJudge === true || options2.aiJudgeRun !== void 0 || options2.aiJudgePrimary !== void 0)
+  };
+}
+function getBackgroundBasicEvaluationHandleOptions(aiJudgeRequested, judgeOff = false) {
+  return {
+    persistEvaluationHandle: true,
+    deferEvaluationHandleFinalization: aiJudgeRequested || judgeOff
+  };
+}
+function resolveBackgroundBasicCompetitionSynthesize(input) {
+  if (input.judgeOff || input.aiJudgeRequested) return false;
+  return input.synthesize;
+}
+function updateDeferredEvaluationOwnershipAfterFinalization(currentlyOwned, finalizationSucceeded) {
+  return finalizationSucceeded ? false : currentlyOwned;
+}
+function didAuthoritativeWinnerFinalize(result, requested = "completed") {
+  return isDurableHandleCompletion(result, requested);
+}
+function resolveBackgroundCompetitionFailure(result) {
+  const outcome = inferCompetitionFinalOutcome(result);
+  return outcome === "all_failed" || outcome === "timed_out" ? `Competition ended with ${outcome}` : void 0;
+}
+function mapBackgroundWorkerResult(result) {
+  return {
+    success: result.variants.some(
+      (v) => (v.outcome ?? deriveVariantOutcome(v)).verification.status === "passed"
+    ),
+    winner: result.winner ? {
+      variant: result.winner.variant,
+      provider: result.winner.provider,
+      model: result.winner.model,
+      executionMode: result.winner.executionMode
+    } : null,
+    winnerVerification: "winnerVerification" in result ? result.winnerVerification : void 0,
+    synthesis: getWorkerSynthesisResult(result),
+    variants: result.variants.map((v) => ({
+      variant: v.variant,
+      provider: v.provider,
+      model: v.model,
+      executionMode: v.executionMode,
+      success: v.success,
+      outcome: v.outcome ?? deriveVariantOutcome(v),
+      prNumber: v.prNumber,
+      prUrl: v.prUrl,
+      cloudTaskId: v.cloudTaskId,
+      completeness: v.completeness,
+      duration: v.duration,
+      postProviderPhaseDurationsMs: v.postProviderPhaseDurationsMs,
+      errorMessage: v.error?.message,
+      ...buildBackgroundWorkerVariantHealthState(v),
+      timedOut: v.timedOut,
+      terminationReason: v.terminationReason,
+      submittedOnly: v.submittedOnly,
+      inputSpecWarning: v.inputSpecWarning,
+      researchTrace: v.researchTrace
+    }))
+  };
+}
+function buildBackgroundCompetitionFailedState(result, failureMessage) {
+  return {
+    status: "failed",
+    terminationSource: "exception",
+    error: failureMessage,
+    result: mapBackgroundWorkerResult(result)
+  };
+}
+function buildBackgroundResearchExecutionContext(taskId) {
+  const nativeResearchProviders = readEnv(BUILD_RESEARCH_NATIVE_PROVIDERS).value;
+  if (!nativeResearchProviders) return {};
+  const base = getExecutionContext();
+  return {
+    executionContext: createExecutionContext({
+      repoRoot: base.repoRoot,
+      buildDir: base.buildDir,
+      taskId,
+      envOverrides: {
+        BUILD_RESEARCH_NATIVE_PROVIDERS: nativeResearchProviders
+      }
+    })
+  };
+}
+function finalizeDeferredWorkerEvaluationFailure(input) {
+  for (const variant of input.variants ?? []) {
+    updateEvaluationHandleWithResult(input.taskId, variant);
+  }
+  finalizeInterruptedEvaluationHandle(input);
+}
+function getWorkerSynthesisResult(result) {
+  if ("synthesisResult" in result) return result.synthesisResult;
+  if ("synthesis" in result) return result.synthesis ?? void 0;
+  return void 0;
+}
+function refreshWinnerVerification(prompt, result) {
+  result.winnerVerification = buildWinnerVerification({
+    winner: result.winner,
+    variants: result.variants,
+    requiredGatePolicy: resolveRequiredGatePolicyForPhase(prompt, "post-judge")
+  });
+}
+function validateWorkerVariants(variants) {
+  if (!Array.isArray(variants) || variants.length === 0) {
+    throw new Error("Worker variants must be a non-empty array");
+  }
+  return variants.map((variant, index) => {
+    if (typeof variant !== "object" || variant === null) {
+      throw new Error(`Worker variant at index ${index} must be an object`);
+    }
+    const candidate = variant;
+    if (typeof candidate.provider !== "string" || candidate.provider.trim().length === 0) {
+      throw new Error(`Worker variant at index ${index} is missing a valid provider`);
+    }
+    if (typeof candidate.executionMode !== "string" || candidate.executionMode.trim().length === 0) {
+      throw new Error(`Worker variant at index ${index} is missing a valid executionMode`);
+    }
+    if (candidate.model !== void 0 && typeof candidate.model !== "string") {
+      throw new Error(`Worker variant at index ${index} has a non-string model`);
+    }
+    return variant;
+  });
+}
+async function loadExistingWorkerState(statePath) {
+  try {
+    const raw = await readFile(statePath, "utf-8");
+    return parseJsonWithContext(
+      raw,
+      `Background worker state (${statePath})`
+    );
+  } catch {
+    return {};
+  }
+}
+async function loadWorkerConfigFile(configFilePath) {
+  const raw = await readFile(configFilePath, "utf-8");
+  const config = parseJsonWithContext(raw, `Worker config file (${configFilePath})`);
+  if (typeof config.prompt !== "string" || config.prompt.trim().length === 0) {
+    throw new Error(`Worker config file (${configFilePath}) is missing a valid prompt`);
+  }
+  const deliverableContract = parseDeliverableContract(config.deliverableContract);
+  const result = {
+    prompt: config.prompt,
+    variants: validateWorkerVariants(config.variants),
+    ...config.runMetadata !== void 0 ? { runMetadata: readBackgroundRunMetadata(config.runMetadata) } : {},
+    ...typeof config.editsExpected === "boolean" ? { editsExpected: config.editsExpected } : {},
+    ...deliverableContract ? { deliverableContract } : {},
+    ...Array.isArray(config.researchExcludeDomain) && config.researchExcludeDomain.every((item) => typeof item === "string") ? { researchExcludeDomain: config.researchExcludeDomain } : {}
+  };
+  try {
+    await unlink(configFilePath);
+  } catch {
+  }
+  return result;
+}
+async function main() {
+  const startedAt = /* @__PURE__ */ new Date();
+  const statePath = getBackgroundStatePath(options.taskId);
+  const timeoutMinutes = options.timeout ? parseInt(options.timeout, 10) / 6e4 : void 0;
+  const executorTimeoutMinutes = options.executorTimeoutMinutes !== void 0 ? parseFloat(options.executorTimeoutMinutes) : void 0;
+  let activePhase = "startup";
+  let orchestratorTimeoutObserved = false;
+  let orchestratorTimeoutMessage;
+  let stateRecord = {
+    taskId: options.taskId,
+    pid: process.pid,
+    parentPid: process.ppid,
+    status: "running",
+    startedAt: startedAt.toISOString(),
+    activePhase,
+    elapsedMs: 0,
+    timeoutMinutes,
+    executorTimeoutMinutes,
+    orchestratorTimeoutObserved: false,
+    ...options.backlogItemId ? { backlogItemId: options.backlogItemId } : {}
+  };
+  let pendingStateWrite = Promise.resolve();
+  let workerDeferredEvaluationHandleFinalization = false;
+  let workerDeferredEvaluationHandleVariantResults;
+  let workerRetainedJudgedWinner;
+  let detachedWorkerHeartbeat;
+  const writeState = async (patch, phaseOverride) => {
+    const nextWrite = pendingStateWrite.then(async () => {
+      if (patch.status === "completed" && (signalCoordinator.isShuttingDown || signalShutdownStarted)) {
+        const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        const message = "Competition interrupted during shutdown before completed state persistence";
+        failDeferredEvaluationForShutdown(message, completedAt);
+        throw new ExitCodeError(143, message);
+      }
+      activePhase = phaseOverride ?? activePhase;
+      stateRecord = {
+        ...stateRecord,
+        ...patch,
+        activePhase,
+        elapsedMs: Date.now() - startedAt.getTime(),
+        orchestratorTimeoutObserved,
+        orchestratorTimeoutMessage
+      };
+      const existing = await loadExistingWorkerState(statePath);
+      await mkdir(path.dirname(statePath), { recursive: true });
+      await atomicWriteJson(statePath, {
+        ...existing,
+        ...stateRecord
+      });
+    });
+    pendingStateWrite = nextWrite.catch((error) => {
+      debugLog(
+        `[variant-worker] Failed to persist worker state at ${statePath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    });
+    await nextWrite;
+  };
+  const unregisterWorker = async () => {
+    await detachedWorkerHeartbeat?.unregister();
+    detachedWorkerHeartbeat = void 0;
+  };
+  const persistBacklogProvenance = async (phase, errorMessage, successOutcome) => {
+    await persistCompeteBacklogProvenance(
+      resolveBuildRoot(process.cwd()),
+      options.backlogItemId,
+      phase,
+      errorMessage,
+      phase === "success" ? { executingPid: null, successOutcome } : void 0
+    );
+  };
+  const failDeferredEvaluationForShutdown = (errorMessage, completedAt) => {
+    if (!workerDeferredEvaluationHandleFinalization) {
+      return;
+    }
+    finalizeDeferredWorkerEvaluationFailure({
+      taskId: options.taskId,
+      variants: workerDeferredEvaluationHandleVariantResults,
+      completedAt,
+      errorMessage,
+      retainedJudgedWinner: workerRetainedJudgedWinner
+    });
+    workerDeferredEvaluationHandleFinalization = false;
+  };
+  const throwIfSignalShutdownStarted = (phase) => {
+    if (!signalCoordinator.isShuttingDown) {
+      return;
+    }
+    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const message = `Competition interrupted during shutdown before ${phase}`;
+    failDeferredEvaluationForShutdown(message, completedAt);
+    throw new ExitCodeError(143, message);
+  };
+  let signalShutdownStarted = false;
+  const shutdownForSignal = async (signal) => {
+    if (signalShutdownStarted) {
+      return;
+    }
+    signalShutdownStarted = true;
+    const terminatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      await writeState(
+        {
+          status: "terminated",
+          terminatedAt,
+          signalReceivedAt: terminatedAt,
+          signal,
+          signalDiagnostics: {
+            pid: process.pid,
+            parentPid: process.ppid,
+            platform: process.platform,
+            uptimeMs: Math.round(process.uptime() * 1e3),
+            cwd: process.cwd(),
+            argv: process.argv.slice(0, 8),
+            activePhase
+          },
+          terminationSource: "signal",
+          error: `Background worker received ${signal}`
+        },
+        "shutdown"
+      );
+    } catch (error) {
+      console.error(
+        `[Worker ${process.pid}] Failed to persist ${signal} termination state:`,
+        error
+      );
+    }
+    await persistBacklogProvenance("failure", `Interrupted by ${signal}`);
+    try {
+      if (workerDeferredEvaluationHandleFinalization) {
+        failDeferredEvaluationForShutdown(`Background worker received ${signal}`, terminatedAt);
+      } else {
+        finalizeEvaluationHandle(
+          options.taskId,
+          createEvaluationHandleFinalState({
+            outcome: "error",
+            completedAt: terminatedAt,
+            errorMessage: `Background worker received ${signal}`,
+            winner: null
+          })
+        );
+      }
+    } catch (finalizeError) {
+      console.error(
+        `[Worker ${process.pid}] Failed to finalize evaluation handle on ${signal}:`,
+        finalizeError
+      );
+    }
+    if (workerDeferredEvaluationHandleVariantResults) {
+      const buildDir = resolveBuildDirFromContext();
+      await cleanupSynthesisInputPatches(workerDeferredEvaluationHandleVariantResults, {
+        expectedRoot: resolveSynthesisInputPatchDir(buildDir, options.taskId)
+      });
+    }
+    await unregisterWorker();
+  };
+  const signalCleanupName = `BackgroundWorker:${options.taskId}:${process.pid}`;
+  const workerSignalCleanup = LabPathResolver.getInstance().bindCurrentContext(
+    async (context) => {
+      if (context.reason !== "SIGINT" && context.reason !== "SIGTERM" && context.reason !== "SIGHUP") {
+        return;
+      }
+      await shutdownForSignal(context.reason);
+    }
+  );
+  signalCoordinator.register(signalCleanupName, workerSignalCleanup, {
+    priority: "critical",
+    phase: "global-cleanup"
+  });
+  const removeSignalHandlers = () => {
+    signalCoordinator.unregister(signalCleanupName);
+  };
+  const runNormalCleanupHandlers = async (reason) => {
+    try {
+      await signalCoordinator.runCleanupHandlers(reason, {
+        timeoutMs: BACKGROUND_WORKER_FINAL_CLEANUP_TIMEOUT_MS,
+        excludeNames: [signalCleanupName]
+      });
+    } catch (error) {
+      const message = sanitizeString(error instanceof Error ? error.message : String(error));
+      console.error(`[Worker ${process.pid}] Failed during ${reason} cleanup: ${message}`);
+    }
+  };
+  try {
+    console.log(`[Worker ${process.pid}] Starting background task ${options.taskId}`);
+    await writeState(
+      {
+        status: "running",
+        taskIdSource: "cli-arg"
+      },
+      "startup"
+    );
+    let prompt;
+    let variants;
+    let editsExpected;
+    let deliverableContract;
+    let researchExcludeDomain;
+    let runMetadata;
+    let latestJudgeDecision;
+    let judgeError;
+    activePhase = "loading_config";
+    if (options.configFile) {
+      const loadedConfig = await loadWorkerConfigFile(options.configFile);
+      prompt = loadedConfig.prompt;
+      variants = loadedConfig.variants;
+      editsExpected = loadedConfig.editsExpected;
+      deliverableContract = loadedConfig.deliverableContract;
+      researchExcludeDomain = loadedConfig.researchExcludeDomain;
+      runMetadata = loadedConfig.runMetadata;
+    } else {
+      if (!options.prompt || !options.variants) {
+        throw new Error("Worker requires either --config-file or both --prompt and --variants");
+      }
+      prompt = options.prompt;
+      variants = validateWorkerVariants(
+        parseJsonWithContext(options.variants, "Worker variants")
+      );
+    }
+    await writeState(
+      {
+        promptSource: options.configFile ? "config-file" : "inline",
+        configFile: options.configFile,
+        variantCount: variants.length,
+        variants: summarizeVariants(variants)
+      },
+      "loading_config"
+    );
+    activePhase = "registering_process";
+    detachedWorkerHeartbeat = await startDetachedWorkerRegistryHeartbeat({
+      taskId: options.taskId,
+      command: "build compete (background worker)",
+      owner: "compete",
+      intervalMs: WORKER_REGISTRY_HEARTBEAT_MS
+    });
+    if (!detachedWorkerHeartbeat.active) {
+      debugLog("[variant-worker] Detached worker registry heartbeat unavailable");
+    }
+    await writeState(
+      {
+        status: "running"
+      },
+      "executing_variants"
+    );
+    const { aiJudgeRequested, judgeOff } = resolveBackgroundBasicJudgeState(options);
+    const basicEvaluationHandleOptions = getBackgroundBasicEvaluationHandleOptions(
+      aiJudgeRequested,
+      judgeOff
+    );
+    workerDeferredEvaluationHandleFinalization = basicEvaluationHandleOptions.deferEvaluationHandleFinalization;
+    let requiredWinnerFinalizationError;
+    const finalizeAuthoritativeWorkerWinner = (basicResult2, judgeOff2) => {
+      const requiredGatePolicy = resolveRequiredGatePolicyForPhase(prompt, "post-judge");
+      for (const variant of basicResult2.variants)
+        finalizeVariantVerification(variant, requiredGatePolicy);
+      const requireHandle = workerDeferredEvaluationHandleFinalization;
+      const finalizeResult = finalizeWorkerWinner(options.taskId, basicResult2, {
+        judgeOff: judgeOff2,
+        requireHandle,
+        runMetadata,
+        aiJudgeRequested,
+        aiJudgePrimary: options.aiJudgePrimary,
+        latestDecision: latestJudgeDecision,
+        judgeError,
+        requiredGatePolicy
+      });
+      const requestedStatus = !judgeOff2 && resolveBackgroundCompetitionFailure(basicResult2) !== void 0 ? "failed" : "completed";
+      const durable = didAuthoritativeWinnerFinalize(finalizeResult, requestedStatus);
+      if (requireHandle && !durable) {
+        requiredWinnerFinalizationError = `Required evaluation handle did not reach durable ${requestedStatus} state (kind=${finalizeResult.kind})`;
+      }
+      workerDeferredEvaluationHandleFinalization = updateDeferredEvaluationOwnershipAfterFinalization(
+        workerDeferredEvaluationHandleFinalization,
+        durable || !requireHandle || requiredWinnerFinalizationError !== void 0
+      );
+    };
+    const {
+      maxConcurrent: workerConfiguredMaxConcurrent,
+      worktreeMax: workerConfiguredWorktreeMax
+    } = await loadConfiguredConcurrency(options.maxConcurrent);
+    let result;
+    const basicResult = await runBasicCompetition(
+      options.taskId,
+      prompt,
+      variants,
+      {
+        timeoutMinutes,
+        perVariantTimeoutMinutes: executorTimeoutMinutes,
+        maxConcurrentVariants: options.maxConcurrent ?? workerConfiguredMaxConcurrent,
+        providerLimits: resolveProviderConcurrencyOverrides({
+          cliLimits: parseProviderLimits(options.providerLimit)
+        }).overrides,
+        configuredWorktreeMaxConcurrent: workerConfiguredWorktreeMax,
+        verbose: options.verbose || false,
+        preserveWorktrees: options.preserveWorktrees ?? variants.length === 1,
+        synthesize: resolveBackgroundBasicCompetitionSynthesize({
+          synthesize: options.synthesize,
+          aiJudgeRequested,
+          judgeOff
+        }),
+        createPr: options.createPr || false,
+        synthesisTopN: options.synthesisTopN,
+        synthesisStrategy: options.synthesisStrategy,
+        synthesisModel: options.synthesisModel,
+        synthesisTimeoutMs: executorTimeoutMinutes !== void 0 ? executorTimeoutMinutes * 60 * 1e3 : void 0,
+        // Native web-search clearance. This background
+        // worker's env was built by the background-executor, which re-applied
+        // the trusted per-run value (the master strips it from inheritance to
+        // block shell spoofing). Thread it into the executionContext so the
+        // worker's own master re-applies it to variant children — instead of
+        // a process.env fallback, which would be spoofable on foreground runs.
+        ...buildBackgroundResearchExecutionContext(options.taskId),
+        ...basicEvaluationHandleOptions,
+        deliverableContract,
+        initialRunMetadata: runMetadata
+      }
+    );
+    result = basicResult;
+    workerDeferredEvaluationHandleVariantResults = basicResult.variants;
+    if (basicResult.timeout?.globalTimedOut) {
+      workerDeferredEvaluationHandleFinalization = false;
+      orchestratorTimeoutObserved = true;
+      orchestratorTimeoutMessage = `Competition timed out after ${basicResult.timeout.timeoutMs / 6e4} minutes`;
+      throwIfBasicCompetitionGloballyTimedOut(basicResult);
+    }
+    const interruptedBySignal = shouldStopBeforeJudgeOrSynthesis(
+      signalCoordinator.isShuttingDown,
+      basicResult.variants
+    );
+    if (interruptedBySignal) {
+      failDeferredEvaluationForShutdown(
+        "Competition interrupted during shutdown before judge/synthesis completed",
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+      throw new ExitCodeError(143, "Competition interrupted during shutdown");
+    }
+    if (readEnv(BUILD_RESEARCH_NATIVE_PROVIDERS).value) {
+      const traceResult = await persistNativeResearchTraces({
+        variants: basicResult.variants,
+        taskId: options.taskId,
+        // The env var IS the parent's clearance decision for this run, so it is
+        // also the authoritative cleared set here.
+        clearedProviders: parseNativeResearchProviders(),
+        excludedDomains: researchExcludeDomain
+      });
+      for (const failure of traceResult.failures) {
+        debugLog(
+          `[Worker ${process.pid}] Failed to persist citation trace for ${failure.variantId}: ${failure.error}`
+        );
+      }
+    }
+    throwIfSignalShutdownStarted("judge/synthesis");
+    if (aiJudgeRequested) {
+      let synthesisJudgeContext;
+      try {
+        const judgeResult = await selectWinnerWithJudge(prompt, basicResult.variants, {
+          taskId: options.taskId,
+          useAIJudge: true,
+          aiJudgeModel: options.aiJudgeModel,
+          aiJudgeVerbose: options.aiJudgeVerbose || false,
+          aiJudgeShowRationale: options.aiJudgeShowRationale || false,
+          aiJudgeVerbosity: options.aiJudgeVerbosity,
+          aiJudgeMinScore: options.aiJudgeMinScore,
+          aiJudgeConfidenceThreshold: options.aiJudgeConfidenceThreshold,
+          aiJudgeStreaming: options.aiJudgeStreaming || false,
+          aiJudgeTelemetry: options.aiJudgeTelemetry !== false,
+          aiJudgeRun: options.aiJudgeRun,
+          aiJudgePrimary: options.aiJudgePrimary,
+          judgeModels: options.judgeModels,
+          judgeModel: options.judgeModel,
+          judgeAllowUnsafeModel: options.judgeAllowUnsafeModel,
+          judgeStrict: options.judgeStrict || false,
+          verificationMode: options.verificationMode,
+          judgeProfile: options.judgeProfile,
+          anonymizeJudge: resolveWorkerAnonymizeJudge(options),
+          editsExpected,
+          executionIntentEffective: deliverableContract?.executionIntentEffective
+        });
+        synthesisJudgeContext = judgeResult.synthesisContext;
+        latestJudgeDecision = judgeResult.decision;
+        basicResult.winner = resolveBackgroundJudgeWinner({
+          prompt,
+          variants: basicResult.variants,
+          judgedWinner: judgeResult.winner,
+          evaluatedVariants: judgeResult.evaluatedVariants
+        });
+        for (const variant of basicResult.variants) {
+          finalizeVariantVerification(
+            variant,
+            resolveRequiredGatePolicyForPhase(prompt, "post-judge")
+          );
+        }
+        if (judgeResult.winner) {
+          await persistJudgeResults(
+            options.taskId,
+            basicResult.variants,
+            judgeResult.winner,
+            resolveBuildDirFromContext()
+          );
+        }
+        if (basicResult.winner) {
+          workerRetainedJudgedWinner = {
+            winner: basicResult.winner,
+            decision: judgeResult.decision,
+            primaryJudge: resolveRunSummaryPrimaryJudge(
+              options.aiJudgePrimary,
+              basicResult.winner
+            )
+          };
+        }
+      } catch (error) {
+        judgeError = sanitizeString(error instanceof Error ? error.message : String(error));
+        console.warn(
+          `[Worker ${process.pid}] AI judge failed in background basic mode: ${error instanceof Error ? error.message : String(error)}`
+        );
+        basicResult.winner = null;
+      }
+      refreshWinnerVerification(prompt, basicResult);
+      const shouldSynthesizeAfterJudge = shouldRunCompetitionSynthesis({
+        synthesize: options.synthesize,
+        deliverableContract: editsExpected === void 0 ? void 0 : {
+          editsExpected
+        },
+        variantCount: basicResult.variants.length,
+        hasWinner: basicResult.winner !== null
+      });
+      if (shouldSynthesizeAfterJudge) {
+        const synthesisStrategy = options.synthesisStrategy ?? "agentic-synthesis";
+        const synthesisAttempt = await attemptSynthesisWithGateValidation(
+          options.taskId,
+          prompt,
+          basicResult.variants,
+          {
+            synthesisTopN: options.synthesisTopN ?? 2,
+            synthesisStrategy,
+            synthesisModel: options.synthesisModel,
+            synthesisTimeoutMs: executorTimeoutMinutes !== void 0 ? executorTimeoutMinutes * 60 * 1e3 : void 0,
+            preserveWorktrees: options.preserveWorktrees ?? variants.length === 1,
+            repoRoot: resolveBuildRoot(process.cwd()),
+            createPr: options.createPr || false,
+            selectedWinner: basicResult.winner ?? void 0,
+            judgeContext: synthesisJudgeContext,
+            aiJudgeModel: options.aiJudgeModel,
+            judgeModels: options.judgeModels,
+            judgeModel: options.judgeModel,
+            judgeAllowUnsafeModel: options.judgeAllowUnsafeModel,
+            judgeConfigCwd: process.cwd()
+          },
+          options.verbose || false
+        );
+        if (synthesisAttempt) {
+          basicResult.synthesisResult = synthesisAttempt.mergedResult;
+          const eligibleSynthesisDeliveryVariant = shouldPromoteBackgroundSynthesisDelivery({
+            synthesisVariant: synthesisAttempt.synthesisVariant,
+            synthesisApplied: synthesisAttempt.mergedResult?.synthesisApplied,
+            gatesPassed: synthesisAttempt.gatesPassed,
+            strategy: synthesisStrategy,
+            complementaryPatchApplied: synthesisAttempt.mergedResult?.complementaryPatchApplied
+          }) && synthesisAttempt.synthesisVariant ? synthesisAttempt.synthesisVariant : void 0;
+          if (eligibleSynthesisDeliveryVariant) {
+            eligibleSynthesisDeliveryVariant.outcome = eligibleSynthesisDeliveryVariant.outcome ?? deriveVariantOutcome(eligibleSynthesisDeliveryVariant);
+            await persistBackgroundSynthesisDeliveryVariant({
+              taskId: options.taskId,
+              buildDir: resolveBuildDirFromContext(),
+              variant: eligibleSynthesisDeliveryVariant
+            });
+          }
+          updateEvaluationHandleWithSynthesisResult(options.taskId, synthesisAttempt.mergedResult);
+          if (eligibleSynthesisDeliveryVariant) {
+            basicResult.variants.push(eligibleSynthesisDeliveryVariant);
+            basicResult.synthesisDeliveryVariant = eligibleSynthesisDeliveryVariant;
+            basicResult.winnerIsSynthesis = false;
+          }
+        }
+      } else {
+        const buildDir = resolveBuildDirFromContext();
+        await cleanupSynthesisInputPatches(basicResult.variants, {
+          expectedRoot: resolveSynthesisInputPatchDir(buildDir, options.taskId)
+        });
+      }
+      throwIfSignalShutdownStarted("winner finalization");
+      finalizeAuthoritativeWorkerWinner(basicResult, judgeOff);
+    } else if (variants.length > 1) {
+      basicResult.winner = null;
+      refreshWinnerVerification(prompt, basicResult);
+      const buildDir = resolveBuildDirFromContext();
+      await cleanupSynthesisInputPatches(basicResult.variants, {
+        expectedRoot: resolveSynthesisInputPatchDir(buildDir, options.taskId)
+      });
+      throwIfSignalShutdownStarted("winner finalization");
+      finalizeAuthoritativeWorkerWinner(basicResult, judgeOff);
+    } else if (judgeOff) {
+      refreshWinnerVerification(prompt, basicResult);
+      const buildDir = resolveBuildDirFromContext();
+      await cleanupSynthesisInputPatches(basicResult.variants, {
+        expectedRoot: resolveSynthesisInputPatchDir(buildDir, options.taskId)
+      });
+      throwIfSignalShutdownStarted("identity finalization");
+      finalizeAuthoritativeWorkerWinner(basicResult, true);
+    }
+    throwIfSignalShutdownStarted("success state persistence");
+    const competitionFailure = resolveBackgroundCompetitionFailure(result);
+    if (competitionFailure !== void 0) {
+      await writeState(
+        {
+          ...buildBackgroundCompetitionFailedState(result, competitionFailure),
+          failedAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        "writing_result"
+      );
+      throw new ExitCodeError(1, competitionFailure);
+    }
+    await writeState(
+      {
+        status: requiredWinnerFinalizationError ? "failed" : "completed",
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        terminationSource: requiredWinnerFinalizationError ? "exception" : "success",
+        ...requiredWinnerFinalizationError ? { error: requiredWinnerFinalizationError } : {},
+        result: mapBackgroundWorkerResult(result)
+      },
+      "writing_result"
+    );
+    if (requiredWinnerFinalizationError) {
+      throw new ExitCodeError(1, requiredWinnerFinalizationError);
+    }
+    console.log(`[Worker ${process.pid}] Task ${options.taskId} completed successfully`);
+    await persistBacklogProvenance(
+      "success",
+      void 0,
+      resolveCompeteBacklogSuccessOutcome({
+        winner: result.winner,
+        completionApplyRan: true,
+        createPr: options.createPr
+      })
+    );
+    activePhase = "cleanup";
+    await runNormalCleanupHandlers("background-worker exit");
+    await unregisterWorker();
+    removeSignalHandlers();
+    return 0;
+  } catch (error) {
+    console.error(
+      `[Worker ${process.pid}] Task ${options.taskId} failed: ${sanitizeString(
+        error instanceof Error ? error.message : String(error)
+      )}`
+    );
+    const failedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const errorMessage = sanitizeString(error instanceof Error ? error.message : "Unknown error");
+    try {
+      if (isOrchestratorTimeoutError(error)) {
+        orchestratorTimeoutObserved = true;
+        orchestratorTimeoutMessage = error.message;
+      }
+      if (signalCoordinator.isShuttingDown || signalShutdownStarted) {
+        await writeState({ failedAt, shutdownError: errorMessage }, "cleanup");
+      } else {
+        await writeState(
+          {
+            status: "failed",
+            failedAt,
+            terminationSource: "exception",
+            error: errorMessage
+          },
+          "cleanup"
+        );
+      }
+    } catch (writeError) {
+      console.error("[Worker] Failed to write error state:", writeError);
+    }
+    if (workerDeferredEvaluationHandleFinalization) {
+      finalizeDeferredWorkerEvaluationFailure({
+        taskId: options.taskId,
+        variants: workerDeferredEvaluationHandleVariantResults,
+        completedAt: failedAt,
+        errorMessage,
+        retainedJudgedWinner: workerRetainedJudgedWinner
+      });
+      workerDeferredEvaluationHandleFinalization = false;
+    }
+    if (workerDeferredEvaluationHandleVariantResults) {
+      const buildDir = resolveBuildDirFromContext();
+      await cleanupSynthesisInputPatches(workerDeferredEvaluationHandleVariantResults, {
+        expectedRoot: resolveSynthesisInputPatchDir(buildDir, options.taskId)
+      });
+    }
+    await persistBacklogProvenance("failure", errorMessage);
+    await runNormalCleanupHandlers("background-worker fatal-exit");
+    await unregisterWorker();
+    removeSignalHandlers();
+    return 1;
+  }
+}
+function isExecutedDirectly() {
+  const entryPoint = process.argv[1];
+  return entryPoint !== void 0 && import.meta.url === pathToFileURL(entryPoint).href;
+}
+function parseWorkerOptions(argv) {
+  program.parse(argv);
+  const parsed = program.opts();
+  if (parsed.judgeRun !== void 0) {
+    parsed.aiJudgeRun = parsed.judgeRun;
+  }
+  if (parsed.judgePrimary !== void 0) {
+    parsed.aiJudgePrimary = parsed.judgePrimary;
+  }
+  if (parsed.backlogItem !== void 0) {
+    parsed.backlogItemId = parsed.backlogItem;
+  }
+  return parsed;
+}
+function establishWorkerExecutionContext(taskId) {
+  const repoRoot = resolveCliRepoRoot(process.cwd());
+  setExecutionContext(
+    createExecutionContext({
+      repoRoot,
+      buildDir: path.join(repoRoot, ".build-project"),
+      taskId,
+      envOverrides: {}
+    })
+  );
+}
+async function runWorkerEntrypoint(entryOptions = {}) {
+  if (!entryOptions.runtimeAlreadyChecked) {
+    assertBuildRuntimeReady({ command: "worker" });
+  }
+  try {
+    options = parseWorkerOptions(process.argv);
+  } catch (parseError) {
+    console.error(
+      `[Worker ${process.pid}] Failed to parse worker options: ${sanitizeString(
+        parseError instanceof Error ? parseError.message : String(parseError)
+      )}`
+    );
+    return 1;
+  }
+  establishWorkerExecutionContext(options.taskId);
+  try {
+    return await main();
+  } catch (fatalError) {
+    console.error(
+      `[Worker ${process.pid}] Fatal bootstrap error: ${sanitizeString(
+        fatalError instanceof Error ? fatalError.message : String(fatalError)
+      )}`
+    );
+    await persistFatalBootstrapFailure(options.taskId, fatalError);
+    return 1;
+  }
+}
+if (isExecutedDirectly()) {
+  runWorkerEntrypoint().then((exitCode) => process.exit(exitCode)).catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(1);
+  });
+}
+export {
+  buildBackgroundCompetitionFailedState,
+  buildBackgroundWorkerVariantHealthState,
+  didAuthoritativeWinnerFinalize,
+  establishWorkerExecutionContext,
+  finalizeWorkerWinner,
+  getBackgroundBasicEvaluationHandleOptions,
+  loadWorkerConfigFile,
+  parseWorkerOptions,
+  persistBackgroundSynthesisDeliveryVariant,
+  persistFatalBootstrapFailure,
+  resolveBackgroundBasicCompetitionSynthesize,
+  resolveBackgroundBasicJudgeState,
+  resolveBackgroundCompetitionFailure,
+  runWorkerEntrypoint,
+  shouldPromoteBackgroundSynthesisDelivery,
+  updateDeferredEvaluationOwnershipAfterFinalization
+};
+//# sourceMappingURL=worker-WIWN62MC.js.map