@poetic-ai/poetic 1.42.0

package/dist/worker-7SA2VS2Y.js

@@ -0,0 +1,1435 @@
+import {
+  PRWorkflowOrchestrator,
+  buildJudgeCompletenessTelemetryFromVariants,
+  loadConfiguredConcurrency,
+  persistNativeResearchTraces,
+  shouldStopBeforeJudgeOrSynthesis
+} from "./chunk-OZ4REHIN.js";
+import {
+  parseNativeResearchProviders
+} from "./chunk-LG3PDRTR.js";
+import "./chunk-7MMLMXO6.js";
+import {
+  inferCompetitionFinalOutcome,
+  persistCompeteBacklogProvenance,
+  resolveCompeteBacklogSuccessOutcome,
+  toHandleWinnerMetadata
+} from "./chunk-T5E4NQCM.js";
+import "./chunk-MHLCBZJB.js";
+import {
+  startDetachedWorkerRegistryHeartbeat
+} from "./chunk-BAV2HJXS.js";
+import "./chunk-Q3WIC6GQ.js";
+import "./chunk-IDCSOZVN.js";
+import "./chunk-PYITM4N2.js";
+import "./chunk-YTYIEZQY.js";
+import "./chunk-IRFBN336.js";
+import "./chunk-IKFP2KUR.js";
+import "./chunk-2QJ3H3L7.js";
+import "./chunk-Q3RO7N35.js";
+import "./chunk-Y3J4JMTU.js";
+import "./chunk-LDCF2MKN.js";
+import "./chunk-NM6PMYY4.js";
+import {
+  ProcessRegistry
+} from "./chunk-XPHKYHO4.js";
+import "./chunk-RHVG6UNL.js";
+import "./chunk-CE5OZBYY.js";
+import {
+  ExitCodeError
+} from "./chunk-FUVP64ER.js";
+import "./chunk-OMX5VL43.js";
+import "./chunk-OQ6K46CK.js";
+import "./chunk-6BM72ZMG.js";
+import "./chunk-4V7NAQ4R.js";
+import "./chunk-GNVDBVJP.js";
+import "./chunk-KZ5CJVBP.js";
+import "./chunk-GSV226X6.js";
+import "./chunk-M3HQYKQX.js";
+import "./chunk-XUXVDPSZ.js";
+import "./chunk-VPHVFK4A.js";
+import "./chunk-3AOKYKA7.js";
+import "./chunk-5RBHQYDB.js";
+import "./chunk-BXI4NXL3.js";
+import "./chunk-TAOOYK3P.js";
+import "./chunk-NJVD4PWE.js";
+import {
+  attemptSynthesisWithGateValidation,
+  backfillMasterFinalVariantTelemetry,
+  buildWinnerVerification,
+  cleanupSynthesisInputPatches,
+  resolveSynthesisInputPatchDir,
+  runBasicCompetition,
+  selectWinnerWithJudge,
+  shouldRunCompetitionSynthesis,
+  throwIfBasicCompetitionGloballyTimedOut
+} from "./chunk-DCBZP442.js";
+import "./chunk-IUXNGKA6.js";
+import "./chunk-DDMAFNUK.js";
+import {
+  createEvaluationHandleFinalState,
+  finalizeEvaluationHandle,
+  isDurableHandleCompletion,
+  updateEvaluationHandleWithResult,
+  updateEvaluationHandleWithSynthesisResult
+} from "./chunk-2IUXIGQD.js";
+import "./chunk-6V7HGQFZ.js";
+import "./chunk-I46EG2XQ.js";
+import "./chunk-S2MNWFAG.js";
+import "./chunk-GG6KJYW6.js";
+import "./chunk-527OBWQB.js";
+import "./chunk-BBHRN366.js";
+import "./chunk-L7E6XCRA.js";
+import "./chunk-PTH5E5XO.js";
+import "./chunk-CPLEWXNZ.js";
+import "./chunk-NGK6PEOG.js";
+import "./chunk-4CSS7WVI.js";
+import {
+  resolveDeclaredWinnerVariant
+} from "./chunk-WIFZCHEG.js";
+import "./chunk-6EQKFDBH.js";
+import "./chunk-VTLNJQ44.js";
+import "./chunk-LWTN3WRV.js";
+import {
+  resolveRequiredGatePolicyForPhase
+} from "./chunk-KQEBSK3T.js";
+import "./chunk-I4NPDSCB.js";
+import "./chunk-AX6GWE7V.js";
+import "./chunk-K65546RE.js";
+import "./chunk-RGROYC2G.js";
+import "./chunk-TFTGP7Z7.js";
+import "./chunk-NZGDAWIP.js";
+import "./chunk-5LAMRH4X.js";
+import "./chunk-H66DXFS5.js";
+import "./chunk-3M57DADF.js";
+import "./chunk-CUSRN6RJ.js";
+import "./chunk-4GSN5O5J.js";
+import "./chunk-G3L2L5XZ.js";
+import "./chunk-77I6G4CO.js";
+import "./chunk-NEQUQHOX.js";
+import "./chunk-OGMSYL6J.js";
+import "./chunk-ZIPWI2LY.js";
+import "./chunk-HMVQIPH3.js";
+import "./chunk-GHTZSQB7.js";
+import "./chunk-RE5VZDFQ.js";
+import "./chunk-Z2KYOFHS.js";
+import "./chunk-K54Y7MLK.js";
+import "./chunk-FONNFJXA.js";
+import "./chunk-GPEL3FBM.js";
+import "./chunk-XZYR5EDO.js";
+import "./chunk-7QCZSLBH.js";
+import "./chunk-VXF4Q3FW.js";
+import "./chunk-4RCCF5BR.js";
+import "./chunk-ASEP3M2W.js";
+import "./chunk-BDATUDDJ.js";
+import "./chunk-XHEKQENB.js";
+import "./chunk-PL37JDNA.js";
+import "./chunk-WIRN3F75.js";
+import "./chunk-NSHASMZZ.js";
+import "./chunk-23A26CSN.js";
+import "./chunk-QVFV5IP2.js";
+import "./chunk-JKBHJQMT.js";
+import "./chunk-4IYIZQWV.js";
+import "./chunk-N65O4XTH.js";
+import "./chunk-5D4A7E3D.js";
+import "./chunk-Y5VN7DMP.js";
+import "./chunk-RI4EX2QE.js";
+import "./chunk-ZZZUL4OF.js";
+import "./chunk-YB3JD4E6.js";
+import "./chunk-P7CQGPLS.js";
+import "./chunk-UHT2KRG5.js";
+import "./chunk-HOYBYAOA.js";
+import "./chunk-6EDAJH2I.js";
+import "./chunk-3FLXLLB7.js";
+import "./chunk-5H72XE4H.js";
+import "./chunk-LWCBNGH6.js";
+import "./chunk-DXH5JBRS.js";
+import "./chunk-APPNGGN7.js";
+import "./chunk-5HDP7XZG.js";
+import "./chunk-EK2U3YEG.js";
+import "./chunk-IV2RVAN7.js";
+import "./chunk-MYLH2S4G.js";
+import "./chunk-73BBJOKA.js";
+import "./chunk-IC7I6YIJ.js";
+import "./chunk-U6C3VVWS.js";
+import "./chunk-2XQXYBM2.js";
+import "./chunk-A722DEVA.js";
+import "./chunk-O4G2W3ST.js";
+import "./chunk-6Y5TWI7H.js";
+import "./chunk-UVJ4PJDK.js";
+import "./chunk-LFTQVYBB.js";
+import "./chunk-3ZPQLGV7.js";
+import "./chunk-73NCTWKL.js";
+import "./chunk-VVGEPBPS.js";
+import "./chunk-E74LUIID.js";
+import {
+  deriveVariantOutcome
+} from "./chunk-ATVKCSGT.js";
+import "./chunk-72XCRQED.js";
+import "./chunk-N4VTRA7K.js";
+import "./chunk-ACDIT7OP.js";
+import "./chunk-CFBIG37O.js";
+import "./chunk-KT6VHSPF.js";
+import "./chunk-Q5XIXSHX.js";
+import "./chunk-7T7RUJI7.js";
+import "./chunk-JOSYEJKY.js";
+import "./chunk-2A5CILN3.js";
+import "./chunk-W3JMT2YY.js";
+import "./chunk-CLKSETWE.js";
+import "./chunk-V53UG2OT.js";
+import "./chunk-LKRAR3IH.js";
+import "./chunk-QTCJ5CC5.js";
+import "./chunk-MWHF5V7U.js";
+import "./chunk-3FOZ2VHV.js";
+import "./chunk-P47VN5F4.js";
+import "./chunk-WZ6U3O7I.js";
+import "./chunk-VTW7HP3R.js";
+import "./chunk-4CUY7AFY.js";
+import "./chunk-MWK5UZQ3.js";
+import "./chunk-C3L6YQ7P.js";
+import "./chunk-L4427KOE.js";
+import "./chunk-NS2K2GTP.js";
+import "./chunk-MN6PL4AN.js";
+import "./chunk-NS33V3IM.js";
+import "./chunk-UHRBTZYY.js";
+import "./chunk-KP6YILMU.js";
+import "./chunk-H2AYQIHW.js";
+import "./chunk-FATUVIIN.js";
+import "./chunk-OIS7J26S.js";
+import "./chunk-XPU2XADL.js";
+import "./chunk-AURFMVCD.js";
+import "./chunk-VBNCKCCI.js";
+import "./chunk-SZ7DL357.js";
+import "./chunk-LGHII5ET.js";
+import "./chunk-PJWJ3SAV.js";
+import "./chunk-NRLY536M.js";
+import "./chunk-7DNSNKJV.js";
+import "./chunk-HIO33P3G.js";
+import "./chunk-APV6MK5E.js";
+import "./chunk-ZYG7GGKO.js";
+import "./chunk-PFTQBXS6.js";
+import "./chunk-E3NTPHEO.js";
+import "./chunk-4NXPXE62.js";
+import "./chunk-4VJITV4P.js";
+import "./chunk-GHHFDU2U.js";
+import "./chunk-R6W23LKN.js";
+import "./chunk-UH3JJSHK.js";
+import "./chunk-FC23CTXV.js";
+import "./chunk-36PEBZAF.js";
+import "./chunk-SURZ2WFE.js";
+import "./chunk-SP3LFU6B.js";
+import "./chunk-R4UWBC35.js";
+import "./chunk-2YFUIER7.js";
+import "./chunk-CKNX3TTP.js";
+import "./chunk-FYOILAN5.js";
+import "./chunk-J62KPGII.js";
+import "./chunk-XAONGNST.js";
+import "./chunk-GAFJEYLK.js";
+import "./chunk-H6G7QRMQ.js";
+import "./chunk-J6P3FWWW.js";
+import {
+  formatVariantIdentifier
+} from "./chunk-CP7H3HSP.js";
+import "./chunk-ETYDXCK7.js";
+import "./chunk-BSE4R6XD.js";
+import "./chunk-UR2IBGIM.js";
+import "./chunk-JSWMRQYG.js";
+import "./chunk-XGYF2QMZ.js";
+import {
+  signalCoordinator
+} from "./chunk-72YTZMAM.js";
+import {
+  assertSafePathComponent
+} from "./chunk-S2VQCZO4.js";
+import "./chunk-WMPU2UOV.js";
+import "./chunk-VX3UMWB7.js";
+import "./chunk-XT2ZQVTC.js";
+import "./chunk-YGXKOBQQ.js";
+import "./chunk-V72RMBM4.js";
+import "./chunk-ZDTGECTN.js";
+import "./chunk-G36W2T2S.js";
+import "./chunk-GKN3HMN4.js";
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import "./chunk-S54MKU6V.js";
+import "./chunk-3S62LLWJ.js";
+import "./chunk-45FPSA3B.js";
+import "./chunk-YMX76IOS.js";
+import {
+  redactPersistedTestsExecuted
+} from "./chunk-6Y5U7UFY.js";
+import "./chunk-XV7NZL4B.js";
+import "./chunk-CD7ISXA4.js";
+import "./chunk-QGJDMEOV.js";
+import "./chunk-D5RYINO7.js";
+import "./chunk-6TZJRKNW.js";
+import "./chunk-PCAGC5MR.js";
+import "./chunk-5WCQRDRB.js";
+import "./chunk-5WRLK5KW.js";
+import "./chunk-C57KJOUQ.js";
+import "./chunk-DF5SLDE4.js";
+import "./chunk-TGON4N4O.js";
+import "./chunk-I5WRT7ZR.js";
+import {
+  atomicWriteJson
+} from "./chunk-A3YGID55.js";
+import "./chunk-5EERLVZB.js";
+import "./chunk-XQD2B6BB.js";
+import "./chunk-34CNP2HB.js";
+import "./chunk-KNDYMVWN.js";
+import "./chunk-RWREC3KJ.js";
+import "./chunk-LO23NABI.js";
+import "./chunk-7R2WLDOS.js";
+import "./chunk-LAMKBTXX.js";
+import "./chunk-FD4ERYEG.js";
+import "./chunk-KTMW65UX.js";
+import "./chunk-FHOWVDF5.js";
+import "./chunk-UDMS5AD3.js";
+import "./chunk-MWHLBPNU.js";
+import "./chunk-JLS65NUQ.js";
+import "./chunk-TRSVUPCX.js";
+import "./chunk-FKAUPHMR.js";
+import "./chunk-TSXGRLPR.js";
+import "./chunk-LUVKFFWR.js";
+import "./chunk-ENRGKNR5.js";
+import "./chunk-XB5YLCLB.js";
+import "./chunk-QOCOVLUH.js";
+import "./chunk-2VSQMRCB.js";
+import "./chunk-ON3G73BU.js";
+import "./chunk-3G6FZCRF.js";
+import "./chunk-N5DX4JAK.js";
+import "./chunk-2QLYTVYX.js";
+import {
+  LabPathResolver
+} from "./chunk-7GDRQBQC.js";
+import "./chunk-PGSPX4SU.js";
+import "./chunk-AT4TNPWW.js";
+import "./chunk-GSGD5E4C.js";
+import {
+  createExecutionContext
+} from "./chunk-UI2F6DJ5.js";
+import "./chunk-4BTDUT2S.js";
+import "./chunk-L6OM4A22.js";
+import "./chunk-G4THLFV3.js";
+import "./chunk-RGWHUI5E.js";
+import "./chunk-UUH2RVKS.js";
+import {
+  resolvePoeticRoot
+} from "./chunk-LEIIWPWQ.js";
+import "./chunk-L7JZLXQL.js";
+import "./chunk-IZYIQQ7X.js";
+import {
+  assertPoeticRuntimeReady
+} from "./chunk-JPKSXKNB.js";
+import "./chunk-TAJPCXSB.js";
+import "./chunk-XZE4XARH.js";
+import {
+  debugLog
+} from "./chunk-EJGCZGUF.js";
+import {
+  sanitizeString
+} from "./chunk-LPITVM7M.js";
+import {
+  POETIC_RESEARCH_NATIVE_PROVIDERS,
+  readEnv
+} from "./chunk-5DLKYTQX.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";
+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";
+}
+async function persistBackgroundSynthesisDeliveryVariant(options2) {
+  const safeTaskId = assertSafePathComponent(
+    options2.taskId.replace(/[^A-Za-z0-9._-]/g, "_") || "task",
+    "taskId"
+  );
+  const stateDir = LabPathResolver.getInstance().getStateDir(options2.poeticDir);
+  const variantsDir = path.join(stateDir, "variants");
+  await mkdir(variantsDir, { recursive: true });
+  const filePath = path.join(variantsDir, `${safeTaskId}-synthesis-delivery.json`);
+  const serializable = {
+    ...options2.variant,
+    testsExecuted: redactPersistedTestsExecuted(options2.variant.testsExecuted),
+    outcome: options2.variant.outcome ?? deriveVariantOutcome(options2.variant),
+    isSynthesis: true,
+    success: options2.variant.success === true
+  };
+  if (options2.variant.error instanceof Error) {
+    serializable.error = { message: options2.variant.error.message };
+  }
+  await atomicWriteJson(filePath, serializable);
+  await backfillMasterFinalVariantTelemetry(options2.taskId, options2.variant, {
+    poeticDir: options2.poeticDir
+  }).catch(() => false);
+  return filePath;
+}
+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("--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-criteria-weights <weights>", "AI judge criteria weights").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,multi-agent (no value = ai only)"
+).option("--judge-primary <judge>", "Primary judge for winner selection when multiple judges run").option(
+  "--judge-models <models>",
+  "Judge model shorthand: claude or codex. Codex uses Claude for multi-agent roles."
+).option(
+  "--judge-model <role=provider:model>",
+  "Scoped judge model override: ai, multi-lens, parent, or worker",
+  (value, previous = []) => [...previous, value],
+  []
+).option("--judge-allow-unsafe-model", "Allow unsupported scoped judge model overrides").option(
+  "--judge-strict",
+  "Strict judge mode: no retries/reruns (single-attempt judge evaluations)"
+).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("--local-fast", "Enable local fast execution mode").option("--no-push", "Disable remote branch publication and PR creation").option("--push-local-variants", "Push local variant branches").option("--stream-results", "Stream results").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(
+    resolvePoeticRoot(process.cwd()),
+    ".poetic/telemetry/state/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,
+    strategy: variant.strategy,
+    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 shouldUseBackgroundBasicCompetition(variants) {
+  return variants.length > 0 && variants.every((variant) => variant.isBasicCompetition === true);
+}
+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 getBackgroundAdvancedJudgePolicy(input) {
+  const judgeOff = input.judgeOff === true;
+  return {
+    judgeOff,
+    aiJudge: judgeOff ? false : input.aiJudge === true,
+    aiJudgeRun: judgeOff ? void 0 : input.aiJudgeRun,
+    aiJudgePrimary: judgeOff ? void 0 : input.aiJudgePrimary
+  };
+}
+function resolveBackgroundBasicCompetitionSynthesize(input) {
+  if (input.judgeOff || input.aiJudgeRequested) return false;
+  return input.synthesize;
+}
+function resolveBackgroundAdvancedCompetitionSynthesize(input) {
+  if (input.judgeOff) return false;
+  return shouldRunCompetitionSynthesis({
+    synthesize: input.synthesize,
+    deliverableContract: input.editsExpected === void 0 ? void 0 : {
+      editsExpected: input.editsExpected
+    },
+    variantCount: input.variantCount
+  });
+}
+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,
+      strategy: result.winner.strategy,
+      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,
+      strategy: v.strategy,
+      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(POETIC_RESEARCH_NATIVE_PROVIDERS).value;
+  if (!nativeResearchProviders) return {};
+  const repoRoot = resolvePoeticRoot(process.cwd());
+  return {
+    executionContext: createExecutionContext({
+      repoRoot,
+      poeticDir: path.join(repoRoot, ".poetic"),
+      taskId,
+      envOverrides: {
+        POETIC_RESEARCH_NATIVE_PROVIDERS: nativeResearchProviders
+      }
+    })
+  };
+}
+function finalizeWorkerWinner(taskId, result, options2 = {}) {
+  const winnerMetadata = toHandleWinnerMetadata(result.winner);
+  const inferredOutcome = inferCompetitionFinalOutcome(result);
+  const common = {
+    winnerVerification: result.winnerVerification,
+    completenessTelemetry: buildJudgeCompletenessTelemetryFromVariants(result.variants)
+  };
+  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;
+}
+function finalizeDeferredWorkerEvaluationFailure(input) {
+  for (const variant of input.variants ?? []) {
+    updateEvaluationHandleWithResult(input.taskId, variant);
+  }
+  finalizeEvaluationHandle(
+    input.taskId,
+    createEvaluationHandleFinalState({
+      outcome: "error",
+      completedAt: input.completedAt,
+      errorMessage: input.errorMessage,
+      winner: null
+    })
+  );
+}
+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 resolveBackgroundJudgeWinner(_prompt, variants, judgedWinner) {
+  return {
+    winner: resolveDeclaredWinnerVariant(judgedWinner.variant, variants)
+  };
+}
+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.strategy !== "string" || candidate.strategy.trim().length === 0) {
+      throw new Error(`Worker variant at index ${index} is missing a valid strategy`);
+    }
+    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 result = {
+    prompt: config.prompt,
+    variants: validateWorkerVariants(config.variants),
+    ...typeof config.editsExpected === "boolean" ? { editsExpected: config.editsExpected } : {},
+    ...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 orchestrator;
+  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 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(
+      resolvePoeticRoot(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
+    });
+    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 poeticDir = path.join(resolvePoeticRoot(process.cwd()), ".poetic");
+      await cleanupSynthesisInputPatches(workerDeferredEvaluationHandleVariantResults, {
+        expectedRoot: resolveSynthesisInputPatchDir(poeticDir, options.taskId)
+      });
+    }
+    try {
+      if (orchestrator) {
+        await orchestrator.close();
+      }
+    } catch (error) {
+      const message = sanitizeString(error instanceof Error ? error.message : String(error));
+      console.error(`[Worker ${process.pid}] Failed during ${signal} shutdown cleanup: ${message}`);
+      try {
+        await writeState({ shutdownError: message }, "shutdown");
+      } catch {
+      }
+    }
+    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 researchExcludeDomain;
+    activePhase = "loading_config";
+    if (options.configFile) {
+      const loadedConfig = await loadWorkerConfigFile(options.configFile);
+      prompt = loadedConfig.prompt;
+      variants = loadedConfig.variants;
+      editsExpected = loadedConfig.editsExpected;
+      researchExcludeDomain = loadedConfig.researchExcludeDomain;
+    } 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: "poetic 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 useBasicCompetition = shouldUseBackgroundBasicCompetition(variants);
+    const { aiJudgeRequested, judgeOff } = resolveBackgroundBasicJudgeState(options);
+    const basicEvaluationHandleOptions = getBackgroundBasicEvaluationHandleOptions(
+      aiJudgeRequested,
+      judgeOff
+    );
+    workerDeferredEvaluationHandleFinalization = useBasicCompetition && basicEvaluationHandleOptions.deferEvaluationHandleFinalization;
+    let requiredWinnerFinalizationError;
+    const finalizeAuthoritativeWorkerWinner = (basicResult, judgeOff2) => {
+      const requireHandle = workerDeferredEvaluationHandleFinalization;
+      const finalizeResult = finalizeWorkerWinner(options.taskId, basicResult, {
+        judgeOff: judgeOff2,
+        requireHandle
+      });
+      const requestedStatus = !judgeOff2 && resolveBackgroundCompetitionFailure(basicResult) !== 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;
+    if (useBasicCompetition) {
+      const basicResult = await runBasicCompetition(
+        options.taskId,
+        prompt,
+        variants,
+        {
+          timeoutMinutes,
+          perVariantTimeoutMinutes: executorTimeoutMinutes,
+          maxConcurrentVariants: options.maxConcurrent ?? workerConfiguredMaxConcurrent,
+          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 (Fusion Workstream B1). 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
+        }
+      );
+      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(POETIC_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,
+            aiJudgeCriteriaWeights: options.aiJudgeCriteriaWeights,
+            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)
+          });
+          synthesisJudgeContext = judgeResult.synthesisContext;
+          const finalJudgedWinner = judgeResult.winner ? resolveBackgroundJudgeWinner(prompt, basicResult.variants, judgeResult.winner) : { winner: null };
+          basicResult.winner = finalJudgedWinner.winner;
+        } catch (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: resolvePoeticRoot(process.cwd()),
+              createPr: options.createPr || false,
+              selectedWinner: basicResult.winner ?? void 0,
+              judgeContext: synthesisJudgeContext
+            },
+            options.verbose || false
+          );
+          if (synthesisAttempt) {
+            basicResult.synthesisResult = synthesisAttempt.mergedResult;
+            const eligibleSynthesisDeliveryVariant = shouldPromoteBackgroundSynthesisDelivery({
+              synthesisVariant: synthesisAttempt.synthesisVariant,
+              synthesisApplied: synthesisAttempt.mergedResult?.synthesisApplied,
+              gatesPassed: synthesisAttempt.gatesPassed,
+              strategy: synthesisStrategy
+            }) && synthesisAttempt.synthesisVariant ? synthesisAttempt.synthesisVariant : void 0;
+            if (eligibleSynthesisDeliveryVariant) {
+              eligibleSynthesisDeliveryVariant.outcome = eligibleSynthesisDeliveryVariant.outcome ?? deriveVariantOutcome(eligibleSynthesisDeliveryVariant);
+              const poeticDir = path.join(resolvePoeticRoot(process.cwd()), ".poetic");
+              await persistBackgroundSynthesisDeliveryVariant({
+                taskId: options.taskId,
+                poeticDir,
+                variant: eligibleSynthesisDeliveryVariant
+              });
+            }
+            updateEvaluationHandleWithSynthesisResult(
+              options.taskId,
+              synthesisAttempt.mergedResult
+            );
+            if (eligibleSynthesisDeliveryVariant) {
+              basicResult.variants.push(eligibleSynthesisDeliveryVariant);
+              basicResult.synthesisDeliveryVariant = eligibleSynthesisDeliveryVariant;
+              basicResult.winnerIsSynthesis = false;
+            }
+          }
+        } else {
+          const poeticDir = path.join(resolvePoeticRoot(process.cwd()), ".poetic");
+          await cleanupSynthesisInputPatches(basicResult.variants, {
+            expectedRoot: resolveSynthesisInputPatchDir(poeticDir, options.taskId)
+          });
+        }
+        throwIfSignalShutdownStarted("winner finalization");
+        finalizeAuthoritativeWorkerWinner(basicResult, judgeOff);
+      } else if (variants.length > 1) {
+        basicResult.winner = null;
+        refreshWinnerVerification(prompt, basicResult);
+        const poeticDir = path.join(resolvePoeticRoot(process.cwd()), ".poetic");
+        await cleanupSynthesisInputPatches(basicResult.variants, {
+          expectedRoot: resolveSynthesisInputPatchDir(poeticDir, options.taskId)
+        });
+        throwIfSignalShutdownStarted("winner finalization");
+        finalizeAuthoritativeWorkerWinner(basicResult, judgeOff);
+      } else if (judgeOff) {
+        refreshWinnerVerification(prompt, basicResult);
+        const poeticDir = path.join(resolvePoeticRoot(process.cwd()), ".poetic");
+        await cleanupSynthesisInputPatches(basicResult.variants, {
+          expectedRoot: resolveSynthesisInputPatchDir(poeticDir, options.taskId)
+        });
+        throwIfSignalShutdownStarted("identity finalization");
+        finalizeAuthoritativeWorkerWinner(basicResult, true);
+      }
+    } else {
+      const advancedOrchestrator = new PRWorkflowOrchestrator({
+        verbose: options.verbose || false,
+        timeoutMinutes,
+        executorTimeoutMinutes,
+        ...getBackgroundAdvancedJudgePolicy({
+          judgeOff: options.judgeOff,
+          aiJudge: options.aiJudge,
+          aiJudgeRun: options.aiJudgeRun,
+          aiJudgePrimary: options.aiJudgePrimary
+        }),
+        aiJudgeModel: options.aiJudgeModel,
+        aiJudgeVerbose: options.aiJudgeVerbose || false,
+        aiJudgeShowRationale: options.aiJudgeShowRationale || false,
+        aiJudgeVerbosity: options.aiJudgeVerbosity,
+        aiJudgeCriteriaWeights: options.aiJudgeCriteriaWeights,
+        aiJudgeMinScore: options.aiJudgeMinScore,
+        aiJudgeConfidenceThreshold: options.aiJudgeConfidenceThreshold,
+        aiJudgeStreaming: options.aiJudgeStreaming || false,
+        aiJudgeTelemetry: options.aiJudgeTelemetry !== false,
+        // Default to true
+        judgeModels: options.judgeModels,
+        judgeModel: options.judgeModel,
+        judgeAllowUnsafeModel: options.judgeAllowUnsafeModel,
+        judgeStrict: options.judgeStrict || false,
+        synthesize: resolveBackgroundAdvancedCompetitionSynthesize({
+          synthesize: options.synthesize,
+          judgeOff: options.judgeOff === true,
+          editsExpected,
+          variantCount: variants.length
+        }),
+        synthesisTopN: options.synthesisTopN,
+        synthesisStrategy: options.synthesisStrategy,
+        synthesisModel: options.synthesisModel,
+        createPr: options.createPr || false,
+        verificationMode: options.verificationMode,
+        anonymizeJudge: resolveWorkerAnonymizeJudge(options),
+        preserveWorktrees: options.preserveWorktrees || false,
+        localFast: options.localFast || false,
+        noPush: options.noPush || false,
+        pushLocalVariants: options.pushLocalVariants || false
+      });
+      orchestrator = advancedOrchestrator;
+      try {
+        result = await advancedOrchestrator.executeVariants(options.taskId, prompt, variants);
+      } catch (error) {
+        if (isOrchestratorTimeoutError(error)) {
+          orchestratorTimeoutObserved = true;
+          orchestratorTimeoutMessage = error.message;
+        }
+        throw error;
+      }
+    }
+    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";
+    if (orchestrator) {
+      try {
+        await orchestrator.close();
+      } catch (closeErr) {
+        console.error("[Worker] Failed to close orchestrator after success:", closeErr);
+      }
+    }
+    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)
+      )}`
+    );
+    if (orchestrator) {
+      try {
+        await orchestrator.close();
+      } catch (closeErr) {
+        console.error(
+          `[Worker] Failed to close orchestrator: ${sanitizeString(
+            closeErr instanceof Error ? closeErr.message : String(closeErr)
+          )}`
+        );
+      }
+    }
+    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
+      });
+      workerDeferredEvaluationHandleFinalization = false;
+    }
+    if (workerDeferredEvaluationHandleVariantResults) {
+      const poeticDir = path.join(resolvePoeticRoot(process.cwd()), ".poetic");
+      await cleanupSynthesisInputPatches(workerDeferredEvaluationHandleVariantResults, {
+        expectedRoot: resolveSynthesisInputPatchDir(poeticDir, 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;
+}
+async function runWorkerEntrypoint(entryOptions = {}) {
+  if (!entryOptions.runtimeAlreadyChecked) {
+    assertPoeticRuntimeReady({ command: "worker" });
+  }
+  try {
+    program.parse();
+    options = program.opts();
+    if (options.judgeRun !== void 0) {
+      options.aiJudgeRun = options.judgeRun;
+    }
+    if (options.judgePrimary !== void 0) {
+      options.aiJudgePrimary = options.judgePrimary;
+    }
+  } catch (parseError) {
+    console.error(
+      `[Worker ${process.pid}] Failed to parse worker options: ${sanitizeString(
+        parseError instanceof Error ? parseError.message : String(parseError)
+      )}`
+    );
+    return 1;
+  }
+  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,
+  finalizeWorkerWinner,
+  getBackgroundAdvancedJudgePolicy,
+  getBackgroundBasicEvaluationHandleOptions,
+  loadWorkerConfigFile,
+  persistBackgroundSynthesisDeliveryVariant,
+  persistFatalBootstrapFailure,
+  resolveBackgroundAdvancedCompetitionSynthesize,
+  resolveBackgroundBasicCompetitionSynthesize,
+  resolveBackgroundBasicJudgeState,
+  resolveBackgroundCompetitionFailure,
+  runWorkerEntrypoint,
+  shouldPromoteBackgroundSynthesisDelivery,
+  updateDeferredEvaluationOwnershipAfterFinalization
+};
+//# sourceMappingURL=worker-7SA2VS2Y.js.map