@poetic-ai/poetic 1.42.0

package/dist/variant-worker-KUWKBLAH.js

@@ -0,0 +1,4196 @@
+#!/usr/bin/env node
+import {
+  createCliBreadcrumb,
+  evaluateExecutionSpec
+} from "./chunk-VVLLL7I4.js";
+import {
+  ProcessLifecycleManager,
+  isNativeResearchEnabledFor,
+  scanWebToolEvents
+} from "./chunk-LG3PDRTR.js";
+import {
+  allFailuresAreRegistered,
+  getOrCaptureVerificationBaseline,
+  loadKnownPreExistingFailures,
+  verificationOutcomesFromGateArtifacts,
+  withValidationSlot
+} from "./chunk-XNO4FM6X.js";
+import "./chunk-PYITM4N2.js";
+import {
+  ExitCodeError
+} from "./chunk-FUVP64ER.js";
+import "./chunk-OMX5VL43.js";
+import {
+  classifyTask
+} from "./chunk-FQ7FSZRW.js";
+import {
+  presentUntrustedRepairEvidence,
+  renderRepairConstraints,
+  renderUntrustedCommandOutput,
+  renderUntrustedFailingTests
+} from "./chunk-LRGMHROI.js";
+import "./chunk-QNOB37UH.js";
+import "./chunk-ACKIPAOJ.js";
+import {
+  FIELD_DISPLAY_NAMES,
+  generateSpecQualitySignals
+} from "./chunk-P6VQROCO.js";
+import {
+  WORKER_CLEANUP_BUDGET_MS,
+  estimateTimeoutCompletenessFromScope,
+  parseShortStatSummary
+} from "./chunk-IUXNGKA6.js";
+import {
+  isSensitiveKey,
+  sanitizeSynthesisArtifactForPersistence,
+  sanitizeSynthesisStringForPersistence
+} from "./chunk-GG6KJYW6.js";
+import {
+  ACTIVE_HANDLES_MARKER_PREFIX,
+  CLEANUP_COMPLETE_MARKER_PREFIX,
+  CLEANUP_START_MARKER_PREFIX,
+  POST_PROVIDER_PHASES_MARKER_PREFIX,
+  RESULT_WRITTEN_MARKER_PREFIX
+} from "./chunk-BBHRN366.js";
+import {
+  computeProcessReliabilityMetrics,
+  sanitizeVariantResult
+} from "./chunk-6EQKFDBH.js";
+import {
+  getVerificationResult,
+  hasVerifiedTouchedTestFailure
+} from "./chunk-I4NPDSCB.js";
+import "./chunk-OA4GPILI.js";
+import "./chunk-NEQUQHOX.js";
+import {
+  applyExactArtifactGoalSuccessGate,
+  isSimpleArtifactGoalSatisfied,
+  parseSimpleArtifactGoal
+} from "./chunk-OGMSYL6J.js";
+import {
+  PROVIDER_ACTIVITY_WORKER_EVENT_PREFIX,
+  PROVIDER_OUTPUT_WORKER_EVENT_PREFIX,
+  ResultStreamer
+} from "./chunk-HMVQIPH3.js";
+import "./chunk-GHTZSQB7.js";
+import "./chunk-RE5VZDFQ.js";
+import "./chunk-4RCCF5BR.js";
+import {
+  isValidationArtifactEntry
+} from "./chunk-EJ4ZAWLV.js";
+import {
+  analyzeRepairScope,
+  buildRepairDiffSnapshot,
+  resolveRepairArtifactPolicy
+} from "./chunk-XHEKQENB.js";
+import {
+  compareVerificationStates,
+  extractStableVerificationState,
+  parseVerificationErrorsForChannel
+} from "./chunk-WIRN3F75.js";
+import {
+  captureWorktreeDiff,
+  normalizeWorktreeDiff
+} from "./chunk-QVFV5IP2.js";
+import {
+  getGitChangeSummary
+} from "./chunk-JKBHJQMT.js";
+import "./chunk-5D4A7E3D.js";
+import "./chunk-Y5VN7DMP.js";
+import {
+  runDeterministicTestGateWithArtifacts,
+  runLintOnDiffWithArtifacts
+} from "./chunk-3ZPQLGV7.js";
+import {
+  deriveVariantOutcome
+} from "./chunk-ATVKCSGT.js";
+import "./chunk-72XCRQED.js";
+import {
+  extractChangedFilesMeta
+} from "./chunk-CFBIG37O.js";
+import "./chunk-KT6VHSPF.js";
+import {
+  parsePromptSpec
+} from "./chunk-7T7RUJI7.js";
+import "./chunk-JOSYEJKY.js";
+import "./chunk-VTW7HP3R.js";
+import "./chunk-4CUY7AFY.js";
+import "./chunk-L4427KOE.js";
+import {
+  runTypecheckWithArtifacts
+} from "./chunk-NS2K2GTP.js";
+import "./chunk-MN6PL4AN.js";
+import "./chunk-NS33V3IM.js";
+import {
+  resolveVerificationChannelScope,
+  selectScopedTestCommands
+} from "./chunk-KP6YILMU.js";
+import "./chunk-H2AYQIHW.js";
+import "./chunk-FATUVIIN.js";
+import {
+  setProcessLifecycleManager
+} from "./chunk-PFTQBXS6.js";
+import "./chunk-E3NTPHEO.js";
+import "./chunk-SP3LFU6B.js";
+import "./chunk-2YFUIER7.js";
+import {
+  TelemetryLogger
+} from "./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 "./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 "./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 {
+  mkPoeticTempDir
+} from "./chunk-C57KJOUQ.js";
+import "./chunk-DF5SLDE4.js";
+import "./chunk-TGON4N4O.js";
+import "./chunk-I5WRT7ZR.js";
+import "./chunk-A3YGID55.js";
+import "./chunk-5EERLVZB.js";
+import "./chunk-XQD2B6BB.js";
+import {
+  sanitizeRefPart
+} from "./chunk-34CNP2HB.js";
+import "./chunk-KNDYMVWN.js";
+import "./chunk-RWREC3KJ.js";
+import "./chunk-LO23NABI.js";
+import "./chunk-7R2WLDOS.js";
+import {
+  DEFAULT_PER_VARIANT_TIMEOUT_MINUTES,
+  DEFAULT_REPAIR_LOOP_ITERATION_TIMEOUT_MS,
+  DEFAULT_REPAIR_LOOP_MAX_ITERATIONS
+} from "./chunk-LAMKBTXX.js";
+import "./chunk-FD4ERYEG.js";
+import "./chunk-KTMW65UX.js";
+import "./chunk-FHOWVDF5.js";
+import {
+  PROJECT_SOURCE_EXTENSIONS
+} from "./chunk-UDMS5AD3.js";
+import "./chunk-MWHLBPNU.js";
+import "./chunk-JLS65NUQ.js";
+import "./chunk-TRSVUPCX.js";
+import "./chunk-FKAUPHMR.js";
+import {
+  truncateToByteLimit
+} from "./chunk-TSXGRLPR.js";
+import {
+  ProviderExecutionError
+} from "./chunk-LUVKFFWR.js";
+import {
+  getRuntimeEnv
+} from "./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 {
+  describeVerificationCommand
+} from "./chunk-2QLYTVYX.js";
+import {
+  initializeLabModeFromEnv
+} from "./chunk-7GDRQBQC.js";
+import "./chunk-PGSPX4SU.js";
+import "./chunk-AT4TNPWW.js";
+import "./chunk-GSGD5E4C.js";
+import {
+  mergeExecutionContextEnvOverrides
+} 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 {
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+import {
+  sanitizeError
+} from "./chunk-LPITVM7M.js";
+import {
+  POETIC_ALLOW_OFF_SCOPE_REPAIR,
+  POETIC_COMPLETION_MODE,
+  readEnv
+} from "./chunk-5DLKYTQX.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/cli/variant-worker.ts
+import { randomBytes } from "crypto";
+import { closeSync, fsyncSync, openSync } from "fs";
+import * as fs from "fs/promises";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+import { Command } from "commander";
+import { execa as execa3 } from "execa";
+
+// src/core/verification/baseline-comparison.ts
+var VALID_VERIFICATION_LANGUAGES = /* @__PURE__ */ new Set([
+  "node",
+  "python",
+  "native",
+  "go",
+  "rust",
+  "jvm",
+  "dotnet",
+  "swift",
+  "dart",
+  "ruby",
+  "php",
+  "shell",
+  "r",
+  "sql",
+  "unknown"
+]);
+function languageFor(value) {
+  if (value == null || value.length === 0) return "node";
+  return VALID_VERIFICATION_LANGUAGES.has(value) ? value : "unknown";
+}
+function generateSummaryMessage(comparison) {
+  const parts = [];
+  const totalNew = comparison.tests.newFailures.length + comparison.types.newFailures.length + comparison.lint.newFailures.length;
+  const totalFixed = comparison.tests.fixedIssues.length + comparison.types.fixedIssues.length + comparison.lint.fixedIssues.length;
+  const totalPersisting = comparison.tests.persistingIssues.length + comparison.types.persistingIssues.length + comparison.lint.persistingIssues.length;
+  switch (comparison.verdict) {
+    case "pass":
+      parts.push("No verification issues");
+      break;
+    case "regression":
+      parts.push(`Introduced ${totalNew} new failure(s)`);
+      if (comparison.tests.newFailures.length > 0) {
+        parts.push(`  - ${comparison.tests.newFailures.length} test failure(s)`);
+      }
+      if (comparison.types.newFailures.length > 0) {
+        parts.push(`  - ${comparison.types.newFailures.length} type error(s)`);
+      }
+      if (comparison.lint.newFailures.length > 0) {
+        parts.push(`  - ${comparison.lint.newFailures.length} lint error(s)`);
+      }
+      break;
+    case "improvement":
+      parts.push(`Fixed ${totalFixed} pre-existing issue(s)`);
+      break;
+    case "neutral":
+      parts.push(`No change (${totalPersisting} pre-existing issue(s) unchanged)`);
+      break;
+  }
+  if (totalPersisting > 0 && comparison.verdict !== "neutral") {
+    parts.push(`${totalPersisting} pre-existing issue(s) not penalized`);
+  }
+  return parts.join("\n");
+}
+function statusDidNotRun(status) {
+  return status === "skipped" || status === "unavailable" || status === "not_run";
+}
+function detectGateRegressions(baseline, currentGates) {
+  const build = currentGates.build != null && !statusDidNotRun(currentGates.build.status) && currentGates.build.exitCode !== 0 && baseline.typeErrors.exitCode === 0;
+  const lint = currentGates.lint != null && !statusDidNotRun(currentGates.lint.status) && currentGates.lint.exitCode !== 0 && baseline.lintErrors.exitCode === 0;
+  const test = currentGates.tests != null && !statusDidNotRun(currentGates.tests.status) && currentGates.tests.exitCode !== 0 && baseline.testResults.exitCode === 0;
+  return {
+    build,
+    lint,
+    test,
+    total: Number(build) + Number(lint) + Number(test)
+  };
+}
+function statusFromCommandSummaryExitCode(exitCode) {
+  if (exitCode === 0) return "passed";
+  if (exitCode === 124) return "timeout";
+  return "failed";
+}
+function commandResultsFromSummaries(commands) {
+  if (!commands || commands.length === 0) return void 0;
+  return commands.map((command) => ({
+    command: command.command,
+    language: languageFor(command.language),
+    status: statusFromCommandSummaryExitCode(command.exitCode),
+    exitCode: command.exitCode,
+    outputTail: command.outputTail,
+    parsed: command.parsed,
+    failingTests: command.failedTests
+  }));
+}
+function baselineToStableState(baseline) {
+  const buildCommands = baseline.summary?.gates.build.commands;
+  const lintCommands = baseline.summary?.gates.lint.commands;
+  const testCommands = baseline.summary?.gates.test.commands;
+  const multiBuild = buildCommands && buildCommands.length > 1;
+  const multiLint = lintCommands && lintCommands.length > 1;
+  const multiTest = testCommands && testCommands.length > 1;
+  const singleBuild = buildCommands && buildCommands.length === 1 ? buildCommands[0] : void 0;
+  const singleLint = lintCommands && lintCommands.length === 1 ? lintCommands[0] : void 0;
+  const singleTest = testCommands && testCommands.length === 1 ? testCommands[0] : void 0;
+  const state = extractStableVerificationState({
+    build: {
+      exitCode: multiBuild ? buildCommands.some((c) => c.exitCode !== 0) ? 1 : 0 : singleBuild?.exitCode ?? baseline.typeErrors.exitCode,
+      outputTail: multiBuild ? "" : singleBuild?.outputTail ?? baseline.typeErrors.outputTail,
+      language: languageFor(
+        multiBuild ? baseline.summary?.gates.build.language : singleBuild?.language ?? baseline.summary?.gates.build.language
+      ),
+      commandResults: multiBuild ? commandResultsFromSummaries(buildCommands) : void 0
+    },
+    lint: {
+      exitCode: multiLint ? lintCommands.some((c) => c.exitCode !== 0) ? 1 : 0 : singleLint?.exitCode ?? baseline.lintErrors.exitCode,
+      outputTail: multiLint ? "" : singleLint?.outputTail ?? baseline.lintErrors.outputTail,
+      language: languageFor(
+        multiLint ? baseline.summary?.gates.lint.language : singleLint?.language ?? baseline.summary?.gates.lint.language
+      ),
+      commandResults: multiLint ? commandResultsFromSummaries(lintCommands) : void 0
+    },
+    tests: {
+      exitCode: multiTest ? testCommands.some((c) => c.exitCode !== 0) ? 1 : 0 : singleTest?.exitCode ?? baseline.testResults.exitCode,
+      outputTail: multiTest ? "" : singleTest?.outputTail ?? baseline.testResults.outputTail,
+      language: languageFor(
+        multiTest ? baseline.summary?.gates.test.language : singleTest?.language ?? baseline.summary?.gates.test.language
+      ),
+      failingTests: multiTest ? Array.from(new Set(testCommands.flatMap((c) => c.failedTests ?? []))) : singleTest?.failedTests ?? baseline.testResults.failedTests,
+      commandResults: multiTest ? commandResultsFromSummaries(testCommands) : void 0
+    }
+  });
+  if (!multiBuild && !multiLint && !multiTest && !singleBuild && !singleLint && !singleTest) {
+    const buildFailed = baseline.typeErrors.exitCode !== 0;
+    const lintFailed = baseline.lintErrors.exitCode !== 0;
+    const testFailed = baseline.testResults.exitCode !== 0;
+    const buildIssues = parseVerificationErrorsForChannel(
+      "build",
+      languageFor(baseline.summary?.gates.build.language),
+      baseline.typeErrors.outputTail,
+      buildFailed
+    ).issues;
+    const lintIssues = parseVerificationErrorsForChannel(
+      "lint",
+      languageFor(baseline.summary?.gates.lint.language),
+      baseline.lintErrors.outputTail,
+      lintFailed
+    ).issues;
+    const testIssues = parseVerificationErrorsForChannel(
+      "test",
+      languageFor(baseline.summary?.gates.test.language),
+      baseline.testResults.outputTail,
+      testFailed,
+      baseline.testResults.failedTests
+    ).issues;
+    return {
+      buildIssues,
+      lintIssues,
+      testIssues,
+      totalIssues: buildIssues.size + lintIssues.size + testIssues.size,
+      gates: {
+        build: { passed: baseline.typeErrors.exitCode === 0 },
+        lint: { passed: baseline.lintErrors.exitCode === 0 },
+        test: { passed: baseline.testResults.exitCode === 0 }
+      }
+    };
+  }
+  return {
+    buildIssues: state.buildIssues,
+    lintIssues: state.lintIssues,
+    testIssues: state.testIssues,
+    totalIssues: state.totalIssues,
+    gates: {
+      build: { passed: baseline.typeErrors.exitCode === 0 },
+      lint: { passed: baseline.lintErrors.exitCode === 0 },
+      test: { passed: baseline.testResults.exitCode === 0 }
+    }
+  };
+}
+function determineStableVerdict(delta) {
+  if (delta.hasAnyRegressions) {
+    return "regression";
+  }
+  if (delta.hasAnyImprovements) {
+    return "improvement";
+  }
+  if (delta.totalPersistingIssues > 0) {
+    return "neutral";
+  }
+  return "pass";
+}
+function formatStableIssueLabel(issue) {
+  if (issue.gate === "test") {
+    return issue.file ? `${issue.file}: ${issue.code}` : issue.code;
+  }
+  const loc = issue.line ? `:${issue.line}${issue.col ? `:${issue.col}` : ""}` : "";
+  if (issue.originalMessage) {
+    return `${issue.file}${loc}: ${issue.code} - ${issue.originalMessage}`;
+  }
+  return `${issue.file}${loc}: ${issue.code}`;
+}
+function issueSetToDimensionComparison(issueDelta) {
+  return {
+    newFailures: issueDelta.newIssues.toArray().map(formatStableIssueLabel),
+    fixedIssues: issueDelta.fixedIssues.toArray().map(formatStableIssueLabel),
+    persistingIssues: issueDelta.persistingIssues.toArray().map(formatStableIssueLabel),
+    netChange: issueDelta.netChange
+  };
+}
+function stableComparisonToBaselineComparison(stable) {
+  const tests = issueSetToDimensionComparison(stable.delta.test);
+  const types = issueSetToDimensionComparison(stable.delta.build);
+  const lint = issueSetToDimensionComparison(stable.delta.lint);
+  const totalNewFailures = tests.newFailures.length + types.newFailures.length + lint.newFailures.length;
+  const totalFixedIssues = tests.fixedIssues.length + types.fixedIssues.length + lint.fixedIssues.length;
+  const totalPersistingIssues = tests.persistingIssues.length + types.persistingIssues.length + lint.persistingIssues.length;
+  return {
+    verdict: stable.verdict,
+    tests,
+    types,
+    lint,
+    summary: {
+      totalNewFailures,
+      totalFixedIssues,
+      totalPersistingIssues,
+      shouldPenalize: !stable.passed,
+      scoreAdjustment: 0,
+      message: generateSummaryMessage({ verdict: stable.verdict, tests, types, lint })
+    },
+    baselineRef: stable.baselineRef
+  };
+}
+function compareVerificationOutcomeToBaseline(baseline, currentGates) {
+  return compareCurrentGatesToBaseline(baseline, currentGates);
+}
+function compareCurrentGatesToBaseline(baseline, currentGates) {
+  const baselineState = baselineToStableState(baseline);
+  const currentState = extractStableVerificationState(currentGates);
+  const testVerificationUnavailable = currentGates.tests == null || currentGates.tests.status === "skipped" || currentGates.tests.status === "unavailable" || currentGates.tests.status === "not_run";
+  if (testVerificationUnavailable) {
+    currentState.testIssues = baselineState.testIssues;
+    currentState.totalIssues = currentState.buildIssues.size + currentState.lintIssues.size + currentState.testIssues.size;
+    currentState.gates.test = { ...baselineState.gates.test, unavailable: true };
+  }
+  const delta = compareVerificationStates(baselineState, currentState);
+  const baseVerdict = determineStableVerdict(delta);
+  const gateRegressions = detectGateRegressions(baseline, currentGates);
+  const comparableTestTotalRegressed = !testVerificationUnavailable && baseline.testResults.run !== void 0 && currentGates.tests?.testsRun !== void 0 && currentGates.tests.testsRun < baseline.testResults.run;
+  const gateRegressed = gateRegressions.total > 0 || comparableTestTotalRegressed;
+  const verdict = gateRegressed ? "regression" : baseVerdict;
+  return {
+    delta,
+    baseline: baselineState,
+    current: currentState,
+    baselineRef: baseline.baselineRef,
+    passed: !delta.hasAnyRegressions && !gateRegressed,
+    testVerificationUnavailable,
+    verdict,
+    scoreAdjustment: 0
+  };
+}
+
+// src/orchestrator/verification/verification-loop.ts
+import { execa as execa2 } from "execa";
+
+// src/core/verification/repair-artifacts.ts
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+import { execa } from "execa";
+var DEFAULT_CONFIG = {
+  modes: ["patch"],
+  patchDir: ".poetic/repair-patches",
+  refNamespace: "refs/poetic/repair",
+  branchPrefix: "poetic/repair"
+};
+function sanitizeForPathSegment(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return "unknown";
+  return trimmed.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 200);
+}
+function sanitizeForGitRefSegment(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return "unknown";
+  const safe = trimmed.replace(/[\s~^:?*[\\]+/g, "_").replace(/\.\.+/g, ".").replace(/^\.*/, "").replace(/\/+/g, "/");
+  return (safe || "unknown").slice(0, 200);
+}
+async function generatePatch(worktreePath, baseRef) {
+  const scratch = await mkPoeticTempDir("repair-patch");
+  const indexPath = join(scratch, "index");
+  const env = { ...process.env, GIT_INDEX_FILE: indexPath };
+  try {
+    const readTree = await execa("git", ["read-tree", baseRef], {
+      cwd: worktreePath,
+      env,
+      stdio: "pipe",
+      reject: false
+    });
+    if (readTree.exitCode !== 0) {
+      throw new Error(`Failed to read base tree: ${readTree.stderr}`);
+    }
+    const add = await execa("git", ["add", "-A"], {
+      cwd: worktreePath,
+      env,
+      stdio: "pipe",
+      reject: false
+    });
+    if (add.exitCode !== 0) {
+      throw new Error(`Failed to stage worktree changes: ${add.stderr}`);
+    }
+    const diff = await execa("git", ["diff", "--cached", baseRef, "--"], {
+      cwd: worktreePath,
+      env,
+      stdio: "pipe",
+      reject: false
+    });
+    if (diff.exitCode !== 0) {
+      throw new Error(`Failed to generate patch: ${diff.stderr}`);
+    }
+    return diff.stdout;
+  } finally {
+    await rm(scratch, { recursive: true, force: true });
+  }
+}
+async function createCommitFromPatch(opts) {
+  const scratch = await mkPoeticTempDir("repair");
+  const indexPath = join(scratch, "index");
+  const env = { ...process.env, GIT_INDEX_FILE: indexPath };
+  const patch = opts.patchContent.endsWith("\n") ? opts.patchContent : `${opts.patchContent}
+`;
+  try {
+    const readTree = await execa("git", ["read-tree", opts.baseRef], {
+      cwd: opts.worktreePath,
+      env,
+      stdio: "pipe",
+      reject: false
+    });
+    if (readTree.exitCode !== 0) {
+      throw new Error(`Failed to read base tree: ${readTree.stderr}`);
+    }
+    const apply = await execa("git", ["apply", "--cached", "-"], {
+      cwd: opts.worktreePath,
+      env,
+      input: patch,
+      stdio: "pipe",
+      reject: false
+    });
+    if (apply.exitCode !== 0) {
+      throw new Error(`Failed to apply patch to temp index: ${apply.stderr}`);
+    }
+    const writeTree = await execa("git", ["write-tree"], {
+      cwd: opts.worktreePath,
+      env,
+      stdio: "pipe",
+      reject: false
+    });
+    if (writeTree.exitCode !== 0) {
+      throw new Error(`Failed to write tree: ${writeTree.stderr}`);
+    }
+    const treeSha = writeTree.stdout.trim();
+    const commitTree = await execa(
+      "git",
+      ["commit-tree", treeSha, "-p", opts.baseRef, "-m", opts.message],
+      { cwd: opts.worktreePath, env, stdio: "pipe", reject: false }
+    );
+    if (commitTree.exitCode !== 0) {
+      throw new Error(`Failed to create commit: ${commitTree.stderr}`);
+    }
+    return commitTree.stdout.trim();
+  } finally {
+    await rm(scratch, { recursive: true, force: true });
+  }
+}
+async function savePatchFile(patchContent, patchDir, taskId, variantId, iteration) {
+  const safeTaskId = sanitizeForPathSegment(taskId);
+  const safeVariantId = sanitizeForPathSegment(variantId);
+  const patchPath = join(patchDir, safeTaskId, `${safeVariantId}-iteration-${iteration}.patch`);
+  await mkdir(dirname(patchPath), { recursive: true });
+  await writeFile(patchPath, patchContent, "utf-8");
+  return patchPath;
+}
+async function createGitRef(worktreePath, refNamespace, taskId, variantId, iteration, commitSha) {
+  const safeTaskId = sanitizeForGitRefSegment(taskId);
+  const safeVariantId = sanitizeForGitRefSegment(variantId);
+  const refName = `${refNamespace}/${safeTaskId}/${safeVariantId}/${iteration}`;
+  const updateResult = await execa("git", ["update-ref", refName, commitSha], {
+    cwd: worktreePath,
+    stdio: "pipe",
+    reject: false
+  });
+  if (updateResult.exitCode !== 0) {
+    throw new Error(`Failed to create ref: ${updateResult.stderr}`);
+  }
+  return refName;
+}
+async function createBranch(worktreePath, branchPrefix, taskId, variantId, iteration, commitSha) {
+  const safeTaskId = sanitizeForGitRefSegment(taskId);
+  const safeVariantId = sanitizeForGitRefSegment(variantId);
+  const branchName = `${branchPrefix}/${safeTaskId}/${safeVariantId}/${iteration}`;
+  const result = await execa("git", ["branch", "-f", branchName, commitSha], {
+    cwd: worktreePath,
+    stdio: "pipe",
+    reject: false
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to create branch: ${result.stderr}`);
+  }
+  return branchName;
+}
+async function preserveRepairIteration(worktreePath, baseRef, taskId, variantId, iteration, config = {}) {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const results = [];
+  let patchContent = null;
+  let preservedCommitSha = null;
+  for (const mode of cfg.modes) {
+    try {
+      let artifactPath;
+      switch (mode) {
+        case "patch": {
+          patchContent = patchContent ?? await generatePatch(worktreePath, baseRef);
+          artifactPath = await savePatchFile(
+            patchContent,
+            cfg.patchDir,
+            taskId,
+            variantId,
+            iteration.iteration
+          );
+          break;
+        }
+        case "ref": {
+          patchContent = patchContent ?? await generatePatch(worktreePath, baseRef);
+          preservedCommitSha = preservedCommitSha ?? await createCommitFromPatch({
+            worktreePath,
+            baseRef,
+            patchContent,
+            message: `poetic: preserve repair (${taskId}, ${variantId}, iter ${iteration.iteration})`
+          });
+          artifactPath = await createGitRef(
+            worktreePath,
+            cfg.refNamespace,
+            taskId,
+            variantId,
+            iteration.iteration,
+            preservedCommitSha
+          );
+          break;
+        }
+        case "branch": {
+          patchContent = patchContent ?? await generatePatch(worktreePath, baseRef);
+          preservedCommitSha = preservedCommitSha ?? await createCommitFromPatch({
+            worktreePath,
+            baseRef,
+            patchContent,
+            message: `poetic: preserve repair (${taskId}, ${variantId}, iter ${iteration.iteration})`
+          });
+          artifactPath = await createBranch(
+            worktreePath,
+            cfg.branchPrefix,
+            taskId,
+            variantId,
+            iteration.iteration,
+            preservedCommitSha
+          );
+          break;
+        }
+      }
+      results.push({
+        artifactPath,
+        mode,
+        success: true
+      });
+    } catch (error) {
+      results.push({
+        artifactPath: "",
+        mode,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return results;
+}
+function findBestIteration(iterations) {
+  if (iterations.length === 0) {
+    return null;
+  }
+  let bestIndex = 0;
+  let bestIteration = iterations[0];
+  for (let i = 1; i < iterations.length; i++) {
+    const current = iterations[i];
+    if (current.passed && !bestIteration.passed) {
+      bestIndex = i;
+      bestIteration = current;
+      continue;
+    }
+    if (current.passed === bestIteration.passed) {
+      if (current.newIssueCount < bestIteration.newIssueCount) {
+        bestIndex = i;
+        bestIteration = current;
+        continue;
+      }
+      if (current.newIssueCount === bestIteration.newIssueCount && current.fixedIssueCount > bestIteration.fixedIssueCount) {
+        bestIndex = i;
+        bestIteration = current;
+      }
+    }
+  }
+  return { index: bestIndex, iteration: bestIteration };
+}
+async function applyPatchFile(worktreePath, patchPath) {
+  const raw = await readFile(patchPath, "utf-8");
+  const patchContent = raw.endsWith("\n") ? raw : `${raw}
+`;
+  const result = await execa("git", ["apply", "--3way", "-"], {
+    cwd: worktreePath,
+    input: patchContent,
+    stdio: "pipe",
+    reject: false
+  });
+  if (result.exitCode !== 0) {
+    return {
+      success: false,
+      error: `Failed to apply patch: ${result.stderr}`
+    };
+  }
+  return { success: true };
+}
+async function cherryPickFromRef(worktreePath, refName) {
+  const result = await execa("git", ["cherry-pick", "--no-commit", refName], {
+    cwd: worktreePath,
+    stdio: "pipe",
+    reject: false
+  });
+  if (result.exitCode !== 0) {
+    return {
+      success: false,
+      error: `Failed to cherry-pick: ${result.stderr}`
+    };
+  }
+  return { success: true };
+}
+
+// src/orchestrator/verification/verification-loop.ts
+function channelCommands(channel) {
+  if (Array.isArray(channel.commands) && channel.commands.length > 0) return channel.commands;
+  if (typeof channel.command === "string" && channel.command.trim()) return [channel.command];
+  return [];
+}
+function dominateGateStatus(statuses) {
+  if (statuses.length === 0) return "unavailable";
+  const hard = statuses.find((status) => status === "failed" || status === "error");
+  if (hard) return hard;
+  if (statuses.some((status) => status === "timeout")) return "timeout";
+  if (statuses.some((status) => status === "unavailable")) return "unavailable";
+  if (statuses.some((status) => status === "skipped")) return "skipped";
+  return "passed";
+}
+function isUnavailableCoverage(coverage) {
+  return coverage?.status === "skipped_no_command" || coverage?.status === "skipped_tool_unavailable";
+}
+function isHardGateStatus(status) {
+  return status === "failed" || status === "timeout" || status === "error";
+}
+function buildStatusFromArtifact(build) {
+  if (build.ok) return "passed";
+  if (isUnavailableCoverage(build.verificationCoverage)) return "unavailable";
+  if (build.exitCode === 124) return "timeout";
+  return "failed";
+}
+function lintStatusFromArtifact(lint) {
+  if (isUnavailableCoverage(lint.verificationCoverage)) return "unavailable";
+  if (lint.exitCode === 0) return "passed";
+  if (lint.exitCode === 124) return "timeout";
+  return "failed";
+}
+function testStatusFromArtifact(status) {
+  if (status === "passed") return "passed";
+  if (status === "timeout") return "timeout";
+  if (status === "error") return "error";
+  if (status === "unavailable") return "unavailable";
+  if (status === "skipped") return "skipped";
+  return "failed";
+}
+async function getChangedFiles(worktreePath, baselineRef) {
+  const result = await execa2("git", ["diff", "--name-only", baselineRef, "--"], {
+    cwd: worktreePath,
+    stdio: "pipe",
+    reject: false
+  });
+  const stdout = String(result.stdout ?? "");
+  return stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).sort();
+}
+async function getDiffSize(worktreePath, baselineRef) {
+  const result = await execa2("git", ["diff", "--numstat", baselineRef, "--"], {
+    cwd: worktreePath,
+    stdio: "pipe",
+    reject: false
+  });
+  const stdout = String(result.stdout ?? "");
+  let total = 0;
+  for (const line of stdout.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parts = trimmed.split(/\s+/);
+    if (parts.length < 3) continue;
+    const added = Number.parseInt(parts[0] ?? "0", 10);
+    const deleted = Number.parseInt(parts[1] ?? "0", 10);
+    total += (Number.isFinite(added) ? added : 0) + (Number.isFinite(deleted) ? deleted : 0);
+  }
+  return total;
+}
+async function detectRemovedExportsInPublicBarrels(worktreePath, baselineRef) {
+  const PUBLIC_BARRELS = /* @__PURE__ */ new Set(["src/cli/index.ts", "src/orchestrator/index.ts"]);
+  const result = await execa2("git", ["diff", "-U0", baselineRef, "--", "src"], {
+    cwd: worktreePath,
+    stdio: "pipe",
+    reject: false
+  });
+  const diff = String(result.stdout ?? "");
+  const removed = [];
+  let currentFile = null;
+  for (const line of diff.split(/\r?\n/)) {
+    if (line.startsWith("diff --git ")) {
+      const match = /^diff --git a\/(.+?) b\/(.+)$/.exec(line);
+      currentFile = match?.[2] ?? null;
+      continue;
+    }
+    if (!currentFile) continue;
+    if (!PUBLIC_BARRELS.has(currentFile)) continue;
+    if (line.startsWith("-export") || line.startsWith("- export")) {
+      removed.push(`${currentFile}: ${line.slice(1).trim()}`);
+    }
+  }
+  return {
+    removedExportLines: removed.length,
+    sample: removed.slice(0, 3).join("\n") || void 0
+  };
+}
+async function runDeterministicGates(worktreePath, baselineRef, timeoutMs, changedFiles = []) {
+  return withValidationSlot(
+    `gates:${worktreePath}`,
+    () => runDeterministicGatesUnpaced(worktreePath, baselineRef, timeoutMs, changedFiles),
+    { maxWaitMs: Math.min(5 * 60 * 1e3, Math.max(5e3, timeoutMs)) }
+  );
+}
+async function runDeterministicGatesUnpaced(worktreePath, baselineRef, timeoutMs, changedFiles = []) {
+  const MIN_GATE_TIMEOUT_MS = 5e3;
+  const effectiveTimeoutMs = Math.max(MIN_GATE_TIMEOUT_MS, timeoutMs);
+  const scope = resolveVerificationChannelScope(
+    worktreePath,
+    changedFiles
+  );
+  const buildCommands = channelCommands(scope.build);
+  const lintCommands = channelCommands(scope.lint);
+  const testCommands = selectScopedTestCommands(scope);
+  const buildStart = Date.now();
+  const buildChannelBudgetMs = Math.min(6e4, effectiveTimeoutMs);
+  const buildArtifacts = scope.build.availability === "unavailable" ? {
+    status: "unavailable",
+    exitCode: 127,
+    command: "build (verification unavailable)",
+    durationMs: 0,
+    stdoutTail: "",
+    stderrTail: "",
+    outputTail: "Build verification unavailable: no covering command for changed language.",
+    verificationCoverage: {
+      status: "skipped_no_command",
+      reason: "No covering build/typecheck command for changed language."
+    }
+  } : scope.build.relevant ? await (async () => {
+    if (buildCommands.length > 0) {
+      let remaining = buildChannelBudgetMs;
+      const commandResults = [];
+      for (const command of buildCommands) {
+        if (remaining <= 0) {
+          commandResults.push({
+            command,
+            language: describeVerificationCommand(command).language,
+            status: "timeout",
+            exitCode: 124,
+            durationMs: 0,
+            outputTail: "Build command skipped: channel timeout budget exhausted."
+          });
+          continue;
+        }
+        const cmdStart = Date.now();
+        const build2 = await runTypecheckWithArtifacts(worktreePath, {
+          timeoutMs: remaining,
+          command
+        });
+        const durationMs = Math.max(build2.durationMs ?? 0, Date.now() - cmdStart);
+        remaining = Math.max(0, remaining - durationMs);
+        const status = buildStatusFromArtifact(build2);
+        commandResults.push({
+          command: build2.command,
+          language: build2.language ?? describeVerificationCommand(command).language,
+          status,
+          exitCode: build2.exitCode,
+          durationMs,
+          outputTail: build2.outputTail,
+          stdoutTail: build2.stdoutTail,
+          stderrTail: build2.stderrTail
+        });
+      }
+      const statuses = commandResults.map((r) => r.status);
+      const aggregateStatus = dominateGateStatus(statuses);
+      const representative = commandResults.find((r) => r.status === aggregateStatus) ?? commandResults[0];
+      const totalDuration = commandResults.reduce((sum, r) => sum + (r.durationMs ?? 0), 0);
+      return {
+        status: aggregateStatus,
+        exitCode: representative.exitCode,
+        command: representative.command,
+        durationMs: Math.max(totalDuration, Date.now() - buildStart),
+        stdoutTail: representative.stdoutTail ?? "",
+        stderrTail: representative.stderrTail ?? "",
+        outputTail: representative.outputTail,
+        language: representative.language,
+        verificationCoverage: aggregateStatus === "unavailable" ? {
+          status: "skipped_tool_unavailable",
+          command: representative.command,
+          reason: "One or more scoped build commands were unavailable."
+        } : aggregateStatus === "passed" ? { status: "verified", command: representative.command } : { status: "unverified", command: representative.command },
+        commandResults
+      };
+    }
+    const build = await runTypecheckWithArtifacts(worktreePath, {
+      timeoutMs: buildChannelBudgetMs,
+      ...scope.scoped && scope.build.command ? { command: scope.build.command } : {}
+    });
+    const buildDurationMs = Date.now() - buildStart;
+    const buildStatus = buildStatusFromArtifact(build);
+    return {
+      status: buildStatus,
+      exitCode: build.exitCode,
+      command: build.command,
+      durationMs: Math.max(build.durationMs ?? 0, buildDurationMs),
+      stdoutTail: build.stdoutTail,
+      stderrTail: build.stderrTail,
+      outputTail: build.outputTail,
+      verificationCoverage: build.verificationCoverage,
+      // Carry the SOURCE-tagged language through so the current side parses by the
+      // same (channel, language) the baseline recorded (root invariant). Fall back
+      // to the scoped command's descriptor when the gate did not tag one.
+      language: build.language ?? (scope.build.command ? describeVerificationCommand(scope.build.command).language : void 0)
+    };
+  })() : {
+    // OUT-OF-SCOPE: this channel was intentionally not run for the task scope
+    // (e.g. a Python-only change does not exercise the Node build). This is a
+    // 'skipped' status (deliberately not run), DISTINCT from 'unavailable' (the
+    // tool was relevant but missing/could-not-run). gatesHavePromotableCoverage
+    // allows an out-of-scope 'skipped' build but still rejects an in-scope
+    // 'unavailable' build, so an out-of-scope channel does not block promotion
+    // while a genuinely-missing in-scope tool stays non-promotable (fail-closed).
+    status: "skipped",
+    exitCode: 0,
+    command: "build (not task-relevant)",
+    durationMs: 0,
+    stdoutTail: "",
+    stderrTail: "",
+    outputTail: "Skipped build gate: not task-relevant to the changed files."
+  };
+  const remainingMs = Math.max(MIN_GATE_TIMEOUT_MS, effectiveTimeoutMs - (Date.now() - buildStart));
+  const lintTimeoutMs = remainingMs;
+  const testTimeoutMs = remainingMs;
+  const runLintChannel = async () => {
+    if (scope.lint.availability === "unavailable") {
+      return {
+        status: "unavailable",
+        exitCode: 127,
+        command: "lint (verification unavailable)",
+        durationMs: 0,
+        outputTail: "Lint verification unavailable: no covering command for changed language.",
+        verificationCoverage: {
+          status: "skipped_no_command",
+          reason: "No covering lint command for changed language."
+        }
+      };
+    }
+    if (!scope.lint.relevant) {
+      return {
+        status: "skipped",
+        exitCode: 0,
+        command: "lint (not task-relevant)",
+        durationMs: 0,
+        outputTail: "Skipped lint gate: not task-relevant to the changed files."
+      };
+    }
+    if (lintCommands.length > 0) {
+      let remaining = lintTimeoutMs;
+      const commandResults = [];
+      for (const command of lintCommands) {
+        if (remaining <= 0) {
+          commandResults.push({
+            command,
+            language: describeVerificationCommand(command).language,
+            status: "timeout",
+            exitCode: 124,
+            durationMs: 0,
+            outputTail: "Lint command skipped: channel timeout budget exhausted."
+          });
+          continue;
+        }
+        const lint3 = await runLintOnDiffWithArtifacts(worktreePath, {
+          baseBranch: baselineRef,
+          timeoutMs: remaining,
+          command
+        });
+        remaining = Math.max(0, remaining - (lint3.durationMs ?? 0));
+        commandResults.push({
+          command: lint3.command,
+          language: lint3.language ?? describeVerificationCommand(command).language,
+          status: lintStatusFromArtifact(lint3),
+          exitCode: lint3.exitCode,
+          durationMs: lint3.durationMs,
+          outputTail: lint3.outputTail
+        });
+      }
+      const aggregateStatus = dominateGateStatus(commandResults.map((r) => r.status));
+      const representative = commandResults.find((r) => r.status === aggregateStatus) ?? commandResults[0];
+      return {
+        status: aggregateStatus,
+        exitCode: representative.exitCode,
+        command: representative.command,
+        durationMs: commandResults.reduce((sum, r) => sum + (r.durationMs ?? 0), 0),
+        outputTail: representative.outputTail,
+        language: representative.language,
+        verificationCoverage: aggregateStatus === "unavailable" ? {
+          status: "skipped_tool_unavailable",
+          command: representative.command,
+          reason: "One or more scoped lint commands were unavailable."
+        } : aggregateStatus === "passed" ? { status: "verified", command: representative.command } : { status: "unverified", command: representative.command },
+        commandResults
+      };
+    }
+    const lint2 = await runLintOnDiffWithArtifacts(worktreePath, {
+      baseBranch: baselineRef,
+      timeoutMs: lintTimeoutMs,
+      ...scope.scoped && scope.lint.command ? { command: scope.lint.command } : {}
+    });
+    return {
+      status: lintStatusFromArtifact(lint2),
+      exitCode: lint2.exitCode,
+      command: lint2.command,
+      durationMs: lint2.durationMs,
+      outputTail: lint2.outputTail,
+      verificationCoverage: lint2.verificationCoverage,
+      language: lint2.language ?? (scope.lint.command ? describeVerificationCommand(scope.lint.command).language : void 0)
+    };
+  };
+  const runTestChannel = async () => {
+    if (scope.test.availability === "unavailable") {
+      return {
+        status: "unavailable",
+        exitCode: 127,
+        command: "test (verification unavailable)",
+        durationMs: 0,
+        outputTail: "Test verification unavailable: no covering command for changed language.",
+        failingTests: []
+      };
+    }
+    if (!scope.test.relevant) {
+      return {
+        // OUT-OF-SCOPE: intentionally not run for this task scope. 'skipped' (not
+        // run on purpose) is distinct from 'unavailable' (relevant tool missing).
+        status: "skipped",
+        exitCode: 0,
+        command: "test (not task-relevant)",
+        durationMs: 0,
+        outputTail: "Skipped test gate: not task-relevant to the changed files.",
+        failingTests: []
+      };
+    }
+    if (testCommands.length > 0) {
+      let remaining = testTimeoutMs;
+      const commandResults = [];
+      for (const command of testCommands) {
+        if (remaining <= 0) {
+          commandResults.push({
+            command,
+            language: describeVerificationCommand(command).language,
+            status: "timeout",
+            exitCode: 124,
+            durationMs: 0,
+            outputTail: "Test command skipped: channel timeout budget exhausted.",
+            failingTests: []
+          });
+          continue;
+        }
+        const tests3 = await runDeterministicTestGateWithArtifacts(worktreePath, {
+          baseRef: baselineRef,
+          timeoutMs: remaining,
+          command
+        });
+        remaining = Math.max(0, remaining - (tests3.durationMs ?? 0));
+        const status = testStatusFromArtifact(tests3.status);
+        commandResults.push({
+          command: tests3.command,
+          language: tests3.language ?? describeVerificationCommand(command).language,
+          status,
+          exitCode: tests3.exitCode,
+          durationMs: tests3.durationMs,
+          outputTail: tests3.outputTail,
+          failingTests: tests3.failingTests
+        });
+      }
+      const aggregateStatus = dominateGateStatus(commandResults.map((r) => r.status));
+      const representative = commandResults.find((r) => r.status === aggregateStatus) ?? commandResults[0];
+      const failingTests = Array.from(new Set(commandResults.flatMap((r) => r.failingTests ?? [])));
+      return {
+        status: aggregateStatus,
+        exitCode: representative.exitCode,
+        command: representative.command,
+        durationMs: commandResults.reduce((sum, r) => sum + (r.durationMs ?? 0), 0),
+        outputTail: representative.outputTail,
+        failingTests,
+        language: representative.language,
+        commandResults
+      };
+    }
+    const tests2 = await runDeterministicTestGateWithArtifacts(worktreePath, {
+      baseRef: baselineRef,
+      timeoutMs: testTimeoutMs,
+      ...scope.scoped && scope.test.command ? { command: scope.test.command } : {}
+    });
+    return {
+      status: testStatusFromArtifact(tests2.status),
+      exitCode: tests2.exitCode,
+      command: tests2.command,
+      durationMs: tests2.durationMs,
+      outputTail: tests2.outputTail,
+      failingTests: tests2.failingTests,
+      language: tests2.language ?? (scope.test.command ? describeVerificationCommand(scope.test.command).language : void 0)
+    };
+  };
+  const [lint, tests] = await Promise.all([runLintChannel(), runTestChannel()]);
+  const gates = {
+    build: buildArtifacts,
+    lint: {
+      status: lint.status,
+      exitCode: lint.exitCode,
+      command: lint.command,
+      durationMs: lint.durationMs,
+      outputTail: lint.outputTail,
+      verificationCoverage: lint.verificationCoverage,
+      language: lint.language,
+      ...lint.commandResults ? { commandResults: lint.commandResults } : {}
+    },
+    tests: {
+      status: tests.status,
+      exitCode: tests.exitCode,
+      command: tests.command,
+      durationMs: tests.durationMs,
+      outputTail: tests.outputTail,
+      failingTests: tests.failingTests,
+      language: tests.language,
+      ...tests.commandResults ? { commandResults: tests.commandResults } : {}
+    }
+  };
+  const passed = buildArtifacts.status === "passed" && (tests.status === "passed" || tests.status === "skipped");
+  return { passed, gates };
+}
+function gatesHaveNoHardFailures(gates, checkTestGate) {
+  if (isHardGateStatus(gates.build.status)) return false;
+  if (!checkTestGate) return true;
+  const testStatus = gates.tests?.status;
+  return testStatus === void 0 || !isHardGateStatus(testStatus);
+}
+function gatesHavePromotableCoverage(gates, checkTestGate) {
+  if (gates.build.status === "unavailable") return false;
+  if (!checkTestGate) return true;
+  if (gates.build.status !== "passed" && gates.build.status !== "skipped") return true;
+  const testStatus = gates.tests?.status;
+  return testStatus === "passed" || testStatus === "failed" || testStatus === "timeout" || testStatus === "error";
+}
+function buildVerificationFindings(gates, passedBaseline) {
+  if (passedBaseline) return [];
+  const findings = [];
+  if (isHardGateStatus(gates.build.status)) {
+    findings.push({
+      kind: "build",
+      command: gates.build.command,
+      exitCode: gates.build.exitCode,
+      outputTail: gates.build.outputTail,
+      severity: "error"
+    });
+  }
+  if (gates.tests && gates.tests.status !== "passed" && gates.tests.status !== "skipped" && gates.tests.status !== "unavailable") {
+    findings.push({
+      kind: "test",
+      command: gates.tests.command,
+      exitCode: gates.tests.exitCode,
+      outputTail: gates.tests.outputTail,
+      failingTests: gates.tests.failingTests,
+      severity: "error"
+    });
+  }
+  return findings;
+}
+async function runDeterministicVerificationOnce(params) {
+  const checkTestGate = params.checkTestGate ?? true;
+  const started = Date.now();
+  const gateRun = params.precomputedGates ? {
+    gates: params.precomputedGates,
+    passed: params.precomputedGates.build.status === "passed" && (!checkTestGate || params.precomputedGates.tests?.status === "passed")
+  } : await runDeterministicGates(
+    params.worktreePath,
+    params.baselineRef,
+    params.timeoutMs,
+    params.changedFiles ?? []
+  );
+  let passedBaseline = gatesHaveNoHardFailures(gateRun.gates, checkTestGate);
+  let newIssueCount = 0;
+  let fixedIssueCount = 0;
+  if (params.baseline) {
+    const comparisonOutcomes = verificationOutcomesFromGateArtifacts(gateRun.gates, {
+      source: "verification-loop",
+      cwd: params.worktreePath
+    });
+    const baselineComparison = compareVerificationOutcomeToBaseline(
+      params.baseline,
+      comparisonOutcomes
+    );
+    const gateExitRegressions = cleanBaselineGateExitRegressions(
+      params.baseline,
+      gateRun.gates,
+      checkTestGate
+    );
+    const hardStructuredNewIssueCount = baselineComparison.delta.build.newIssues.size + (checkTestGate ? baselineComparison.delta.test.newIssues.size : 0);
+    passedBaseline = hardStructuredNewIssueCount === 0 && gateExitRegressions.length === 0;
+    const structuredNewIssueCount = checkTestGate ? hardStructuredNewIssueCount : baselineComparison.delta.build.newIssues.size;
+    const unparsedGateRegressionCount = gateExitRegressions.filter((kind) => {
+      if (kind === "build") return baselineComparison.delta.build.newIssues.size === 0;
+      return baselineComparison.delta.test.newIssues.size === 0;
+    }).length;
+    newIssueCount = structuredNewIssueCount + unparsedGateRegressionCount;
+    fixedIssueCount = baselineComparison.delta.totalFixedIssues;
+  }
+  const durationMs = Date.now() - started;
+  const findings = buildVerificationFindings(gateRun.gates, passedBaseline);
+  const promotable = passedBaseline && gatesHavePromotableCoverage(gateRun.gates, checkTestGate);
+  return {
+    verification: {
+      passed: promotable,
+      passedBaseline,
+      findings
+    },
+    verificationLoop: {
+      enabled: true,
+      passed: promotable,
+      passedBaseline,
+      stopReason: passedBaseline ? "single_iteration_no_new_regressions" : "single_iteration_gates_failed",
+      bestIterationIndex: 0,
+      bestIterationPromotable: promotable,
+      iterations: [
+        {
+          iteration: 1,
+          passed: gateRun.passed,
+          passedBaseline,
+          newIssueCount,
+          fixedIssueCount,
+          durationMs,
+          costUsd: 0,
+          cumulativeCostUsd: 0,
+          constraints: {
+            maxFilesTouched: 0,
+            diffSizeCap: 0,
+            apiBreakAllowed: false,
+            violations: []
+          },
+          build: gateRun.gates.build,
+          lint: gateRun.gates.lint,
+          tests: gateRun.gates.tests,
+          ...params.precomputedGates ? { gateSource: "precomputed" } : {}
+        }
+      ]
+    }
+  };
+}
+function gateVector(gates) {
+  const build = gates.build.status === "passed" ? 1 : 0;
+  const lint = 1;
+  const tests = gates.tests?.status === "passed" ? 1 : 0;
+  return [build, lint, tests];
+}
+function isRegression(prev, next) {
+  const [pb, pl, pt] = gateVector(prev);
+  const [nb, nl, nt] = gateVector(next);
+  if (nb < pb) return true;
+  const prevSum = pb + pl + pt;
+  const nextSum = nb + nl + nt;
+  return nextSum < prevSum;
+}
+function cleanBaselineGateExitRegressions(baseline, gates, checkTestGate) {
+  const regressions = [];
+  if (isHardGateStatus(gates.build.status) && gates.build.exitCode !== 0 && baseline.typeErrors.exitCode === 0) {
+    regressions.push("build");
+  }
+  if (checkTestGate && gates.tests && gates.tests.status !== "skipped" && gates.tests.status !== "unavailable" && gates.tests.exitCode !== 0 && baseline.testResults.exitCode === 0) {
+    regressions.push("test");
+  }
+  return regressions;
+}
+function buildRepairPrompt(opts) {
+  const { originalPrompt, iteration, gates, constraints, allowedFiles, scopePolicy } = opts;
+  const parts = [];
+  parts.push(originalPrompt.trimEnd());
+  parts.push("\n\n---\n\n");
+  parts.push(
+    `VERIFICATION-DRIVEN REPAIR (iteration ${iteration}): Fix the deterministic gate failures below.`
+  );
+  parts.push(
+    "Stabilization approach:",
+    "- Prioritize high-leverage, low-cost fixes first (e.g., lint/formatting, obvious type errors).",
+    "- Keep the diff cohesive and targeted; preserve the core solution unless a change is clearly required.",
+    "- Only attempt deeper behavioral/test fixes once cheap failures are resolved or if time remains."
+  );
+  parts.push("Make the MINIMUM change set required to improve gate outcomes.");
+  parts.push(
+    `HARD CONSTRAINTS (enforced): maxFilesTouched=${constraints.maxFilesTouched}, diffSizeCap=${constraints.diffSizeCap}, apiBreakAllowed=${constraints.apiBreakAllowed}`
+  );
+  if (constraints.violations.length > 0) {
+    parts.push(
+      `CONSTRAINT VIOLATIONS DETECTED (must be fixed/undone):
+- ${constraints.violations.join("\n- ")}`
+    );
+  }
+  if (allowedFiles.length > 0) {
+    parts.push(`ALLOWED FILES (derived from prompt/gates):
+- ${allowedFiles.join("\n- ")}`);
+    if (scopePolicy === "strict") {
+      parts.push("SCOPE POLICY: strict - do not modify files outside the allowed list.");
+    }
+  }
+  const gateBlock = (label, g) => {
+    return [
+      `
+${label}:`,
+      `Command: ${g.command}`,
+      `Exit Code: ${g.exitCode}`,
+      `Output (tail):
+${renderUntrustedCommandOutput(g.outputTail)}`
+    ].join("\n");
+  };
+  parts.push(
+    gateBlock("BUILD/TYPECHECK", {
+      command: gates.build.command,
+      exitCode: gates.build.exitCode,
+      outputTail: gates.build.outputTail
+    })
+  );
+  if (gates.lint && gates.lint.status !== "passed") {
+    parts.push(
+      gateBlock("LINT", {
+        command: gates.lint.command,
+        exitCode: gates.lint.exitCode,
+        outputTail: gates.lint.outputTail
+      })
+    );
+  }
+  if (gates.tests && gates.tests.status !== "passed" && gates.tests.status !== "skipped" && gates.tests.status !== "unavailable") {
+    const failing = renderUntrustedFailingTests(gates.tests.failingTests);
+    parts.push(
+      `${gateBlock("TESTS", { command: gates.tests.command, exitCode: gates.tests.exitCode, outputTail: gates.tests.outputTail })}
+${failing}`
+    );
+  }
+  parts.push("\nDo not remove public exports unless explicitly allowed.");
+  parts.push("Keep refactors tightly scoped to what is required for correctness.");
+  parts.push(`
+${renderRepairConstraints()}`);
+  return parts.join("\n");
+}
+var GATE_EVIDENCE_EXTRA_EXTENSIONS = ["json", "css", "scss", "md", "ya?ml", "toml", "snap"];
+function buildGateEvidencePathPattern() {
+  const escapeForClass = (ext) => ext.replace(/[+.]/g, "\\$&");
+  const sourceExtensions = [...PROJECT_SOURCE_EXTENSIONS].map(
+    (ext) => escapeForClass(ext.replace(/^\./, ""))
+  );
+  const extensionAlternation = [...sourceExtensions, ...GATE_EVIDENCE_EXTRA_EXTENSIONS].join("|");
+  return new RegExp(
+    `(?:^|[\\s'"([])((?:\\.{1,2}\\/)?(?:[A-Za-z0-9_.@+-]+\\/)*[A-Za-z0-9_.@+-]+\\.(?:${extensionAlternation}))(?:[:(]|$)`,
+    "gm"
+  );
+}
+var GATE_EVIDENCE_PATH_PATTERN = buildGateEvidencePathPattern();
+function extractFilePathsFromText(text) {
+  if (!text) return [];
+  const paths = /* @__PURE__ */ new Set();
+  for (const match of text.matchAll(GATE_EVIDENCE_PATH_PATTERN)) {
+    const filePath = match[1]?.trim();
+    if (filePath) paths.add(filePath.replace(/^\.\//, ""));
+  }
+  return [...paths];
+}
+function collectIssueFiles(issues) {
+  return issues?.toArray?.().flatMap((issue) => issue.file ? [issue.file] : []) ?? [];
+}
+function deriveAllowedFilesFromGateEvidence(gates, comparison) {
+  const files = /* @__PURE__ */ new Set();
+  for (const file of [
+    ...collectIssueFiles(comparison?.delta.build.newIssues),
+    ...collectIssueFiles(comparison?.delta.lint.newIssues),
+    ...collectIssueFiles(comparison?.delta.test.newIssues),
+    ...extractFilePathsFromText(gates.build.outputTail),
+    ...extractFilePathsFromText(gates.build.stderrTail),
+    ...extractFilePathsFromText(gates.build.stdoutTail),
+    ...extractFilePathsFromText(gates.lint?.outputTail),
+    ...extractFilePathsFromText(gates.tests?.outputTail),
+    ...gates.tests?.failingTests.flatMap(extractFilePathsFromText) ?? []
+  ]) {
+    files.add(file);
+  }
+  return [...files].sort();
+}
+function mergeRepairAllowedFiles(promptAllowedFiles, gateDerivedAllowedFiles) {
+  const merged = /* @__PURE__ */ new Set();
+  for (const file of [...promptAllowedFiles, ...gateDerivedAllowedFiles]) {
+    const normalized = file.trim();
+    if (normalized.length > 0) {
+      merged.add(normalized);
+    }
+  }
+  return [...merged].sort();
+}
+function buildScopedRepairPrompt(opts) {
+  const { originalPrompt, iteration, gates, constraints, comparison, allowedFiles, scopePolicy } = opts;
+  const parts = [];
+  parts.push(originalPrompt.trimEnd());
+  parts.push("\n\n---\n\n");
+  parts.push(
+    `BASELINE-AWARE REPAIR (iteration ${iteration}): Fix only the NEW issues introduced by your changes.`
+  );
+  if (allowedFiles.length > 0) {
+    parts.push(`
+ALLOWED FILES (you may only modify these):
+- ${allowedFiles.join("\n- ")}`);
+    if (scopePolicy === "strict") {
+      parts.push(
+        "\nSCOPE POLICY: strict - Do NOT modify files outside the allowed list, even if they have errors."
+      );
+    } else {
+      parts.push(
+        "\nSCOPE POLICY: expand - You may modify dependent files if they have new errors caused by your changes."
+      );
+    }
+  }
+  parts.push("\nStabilization approach:");
+  parts.push("- Focus ONLY on NEW issues listed below - ignore pre-existing issues.");
+  parts.push("- Prioritize high-leverage, low-cost fixes (lint, obvious type errors).");
+  parts.push("- Keep the diff cohesive; preserve your core solution.");
+  parts.push("- Make the MINIMUM change set to resolve new issues.");
+  const newBuild = comparison.delta.build.newIssues.toArray();
+  const newLint = comparison.delta.lint.newIssues.toArray();
+  const newTest = comparison.delta.test.newIssues.toArray();
+  const totalNew = newBuild.length + newLint.length + newTest.length;
+  if (totalNew > 0) {
+    parts.push(`
+=== NEW ISSUES TO FIX (${totalNew} total) ===`);
+    if (newBuild.length > 0) {
+      parts.push(`
+NEW TYPE ERRORS (${newBuild.length}):`);
+      for (const issue of newBuild.slice(0, 20)) {
+        const loc = issue.line ? `:${issue.line}${issue.col ? `:${issue.col}` : ""}` : "";
+        const message = presentUntrustedRepairEvidence(issue.originalMessage ?? "");
+        parts.push(`- ${issue.file}${loc}: ${issue.code} - ${message}`);
+      }
+      if (newBuild.length > 20) {
+        parts.push(`  ... and ${newBuild.length - 20} more`);
+      }
+    }
+    if (newLint.length > 0) {
+      parts.push(`
+NEW LINT ERRORS (${newLint.length}):`);
+      for (const issue of newLint.slice(0, 20)) {
+        const loc = issue.line ? `:${issue.line}${issue.col ? `:${issue.col}` : ""}` : "";
+        parts.push(`- ${issue.file}${loc}: ${issue.code}`);
+      }
+      if (newLint.length > 20) {
+        parts.push(`  ... and ${newLint.length - 20} more`);
+      }
+    }
+    if (newTest.length > 0) {
+      parts.push(`
+NEW TEST FAILURES (${newTest.length}):`);
+      for (const issue of newTest.slice(0, 10)) {
+        parts.push(`- ${issue.file ? `${issue.file}: ` : ""}${issue.code}`);
+      }
+      if (newTest.length > 10) {
+        parts.push(`  ... and ${newTest.length - 10} more`);
+      }
+    }
+  } else {
+    parts.push("\n=== NO NEW ISSUES ===");
+    parts.push("Your changes have not introduced any new issues vs baseline.");
+    parts.push("If gates are still failing, it is due to pre-existing issues (listed below).");
+  }
+  if (!comparison.passed && totalNew === 0) {
+    const gateBlock = (label, g) => [
+      `
+${label}:`,
+      `Status: ${g.status}`,
+      `Command: ${g.command}`,
+      `Exit Code: ${g.exitCode}`,
+      `Output (tail):
+${renderUntrustedCommandOutput(g.outputTail)}`
+    ].join("\n");
+    parts.push("\n=== UNPARSED GATE REGRESSION OUTPUT ===");
+    parts.push(
+      "A clean baseline gate now exits non-zero, but no stable issue identity could be extracted. Fix the gate failure shown below."
+    );
+    if (gates.build.status !== "passed") {
+      parts.push(gateBlock("BUILD/TYPECHECK", gates.build));
+    }
+    if (gates.lint && gates.lint.status !== "passed") {
+      parts.push(gateBlock("LINT", gates.lint));
+    }
+    if (gates.tests && gates.tests.status !== "passed" && gates.tests.status !== "skipped" && gates.tests.status !== "unavailable") {
+      parts.push(gateBlock("TESTS", gates.tests));
+    }
+  }
+  const persistBuild = comparison.delta.build.persistingIssues.size;
+  const persistLint = comparison.delta.lint.persistingIssues.size;
+  const persistTest = comparison.delta.test.persistingIssues.size;
+  const totalPersist = persistBuild + persistLint + persistTest;
+  if (totalPersist > 0) {
+    parts.push(`
+=== PRE-EXISTING ISSUES (${totalPersist} total - DO NOT fix these) ===`);
+    parts.push("These existed before your changes and are NOT your responsibility:");
+    if (persistBuild > 0) parts.push(`- ${persistBuild} type error(s)`);
+    if (persistLint > 0) parts.push(`- ${persistLint} lint error(s)`);
+    if (persistTest > 0) parts.push(`- ${persistTest} test failure(s)`);
+  }
+  parts.push(
+    `
+HARD CONSTRAINTS: maxFilesTouched=${constraints.maxFilesTouched}, diffSizeCap=${constraints.diffSizeCap}`
+  );
+  if (constraints.violations.length > 0) {
+    parts.push(`CONSTRAINT VIOLATIONS:
+- ${constraints.violations.join("\n- ")}`);
+  }
+  parts.push("\nDo not remove public exports unless explicitly allowed.");
+  parts.push(`
+${renderRepairConstraints()}`);
+  return parts.join("\n");
+}
+async function runVerificationDrivenRepairLoop(params) {
+  const {
+    config,
+    worktreePath,
+    baselineRef,
+    originalPrompt,
+    executeRepair,
+    baseline,
+    taskId,
+    variantId
+  } = params;
+  const repairMode = config.repairMode ?? "auto";
+  const scopePolicy = config.scopePolicy ?? "strict";
+  const allowedFiles = config.allowedFiles ?? [];
+  const repairSaveModes = config.repairSaveModes ?? ["patch"];
+  const checkTestGate = config.checkTestGate ?? true;
+  if (!config.enabled || repairMode === "none") {
+    return {
+      verification: { passed: true, passedBaseline: true, findings: [] },
+      verificationLoop: {
+        enabled: false,
+        passed: true,
+        passedBaseline: true,
+        bestIterationIndex: 0,
+        bestIterationPromotable: true,
+        iterations: []
+      }
+    };
+  }
+  const repairBaseRefResult = await execa2("git", ["rev-parse", "HEAD"], {
+    cwd: worktreePath,
+    stdio: "pipe",
+    reject: false
+  });
+  const repairBaseRef = (repairBaseRefResult.exitCode ?? 0) === 0 ? repairBaseRefResult.stdout.trim() : baselineRef;
+  const iterations = [];
+  const initialCostUsdRaw = Number(params.initialCostUsd ?? 0);
+  const initialCostUsd = Number.isFinite(initialCostUsdRaw) && initialCostUsdRaw > 0 ? initialCostUsdRaw : 0;
+  let cumulativeCostUsd = initialCostUsd;
+  let initialFilesTouched = 0;
+  let initialDiffSize = 0;
+  let stopReason;
+  let bestIterationIndex = 0;
+  const preserved = [];
+  for (let iteration = 1; iteration <= config.maxIterations; iteration++) {
+    const iterStart = Date.now();
+    if (iteration === 1) {
+      const [files, diffSize] = await Promise.all([
+        getChangedFiles(worktreePath, baselineRef),
+        getDiffSize(worktreePath, baselineRef)
+      ]);
+      initialFilesTouched = files.length;
+      initialDiffSize = Math.max(1, diffSize);
+    }
+    const maxFilesTouched = initialFilesTouched + 1;
+    const diffSizeCap = initialDiffSize * 2;
+    const constraints = {
+      maxFilesTouched,
+      diffSizeCap,
+      apiBreakAllowed: config.allowApiBreak,
+      violations: []
+    };
+    const [currentFiles, currentDiffSize, removedExports] = await Promise.all([
+      getChangedFiles(worktreePath, baselineRef),
+      getDiffSize(worktreePath, baselineRef),
+      detectRemovedExportsInPublicBarrels(worktreePath, baselineRef)
+    ]);
+    if (currentFiles.length > maxFilesTouched) {
+      constraints.violations.push(
+        `max_files_touched exceeded: ${currentFiles.length} > ${maxFilesTouched} (${currentFiles.slice(0, 8).join(", ")}${currentFiles.length > 8 ? "\u2026" : ""})`
+      );
+    }
+    if (currentDiffSize > diffSizeCap) {
+      constraints.violations.push(`diff_size_cap exceeded: ${currentDiffSize} > ${diffSizeCap}`);
+    }
+    if (!config.allowApiBreak && removedExports.removedExportLines > 0) {
+      constraints.violations.push(
+        `api_break_detection: removed export lines detected (${removedExports.removedExportLines})${removedExports.sample ? `
+${removedExports.sample}` : ""}`
+      );
+    }
+    const timeboxMs = config.iterationTimeoutMs;
+    const timeRemainingMs = Math.max(0, timeboxMs - (Date.now() - iterStart));
+    const gateRun = constraints.violations.length ? {
+      passed: false,
+      gates: {
+        build: {
+          status: "failed",
+          exitCode: 1,
+          command: "constraint-check",
+          durationMs: 0,
+          stdoutTail: "",
+          stderrTail: "",
+          outputTail: `Constraint violations:
+- ${constraints.violations.join("\n- ")}`
+        }
+      }
+    } : (
+      // Scope the repair-iteration gates to the same changed files used elsewhere
+      // (symmetry with task-scoped baselines). `currentFiles` is the diff vs the
+      // baselineRef computed just above for constraint checks.
+      await runDeterministicGates(worktreePath, baselineRef, timeRemainingMs, currentFiles)
+    );
+    const passed = gateRun.passed;
+    const durationMs = Date.now() - iterStart;
+    let baselineComparison;
+    let passedBaseline = gatesHaveNoHardFailures(gateRun.gates, checkTestGate);
+    let newIssueCount = 0;
+    let fixedIssueCount = 0;
+    if (baseline) {
+      baselineComparison = compareVerificationOutcomeToBaseline(
+        baseline,
+        verificationOutcomesFromGateArtifacts(gateRun.gates, {
+          source: "verification-loop",
+          cwd: worktreePath
+        })
+      );
+      const gateExitRegressions = cleanBaselineGateExitRegressions(
+        baseline,
+        gateRun.gates,
+        checkTestGate
+      );
+      const hardStructuredNewIssueCount = baselineComparison.delta.build.newIssues.size + (checkTestGate ? baselineComparison.delta.test.newIssues.size : 0);
+      passedBaseline = hardStructuredNewIssueCount === 0 && gateExitRegressions.length === 0;
+      const structuredNewIssueCount = checkTestGate ? hardStructuredNewIssueCount : baselineComparison.delta.build.newIssues.size;
+      const comparisonForCounts = baselineComparison;
+      const unparsedGateRegressionCount = gateExitRegressions.filter((kind) => {
+        if (kind === "build") return comparisonForCounts.delta.build.newIssues.size === 0;
+        return comparisonForCounts.delta.test.newIssues.size === 0;
+      }).length;
+      newIssueCount = structuredNewIssueCount + unparsedGateRegressionCount;
+      fixedIssueCount = baselineComparison.delta.totalFixedIssues;
+    }
+    const record = {
+      iteration,
+      passed,
+      passedBaseline,
+      newIssueCount,
+      fixedIssueCount,
+      durationMs,
+      costUsd: 0,
+      cumulativeCostUsd,
+      constraints,
+      gates: gateRun.gates,
+      baselineComparison
+    };
+    iterations.push(record);
+    if (taskId && variantId && repairSaveModes.length > 0) {
+      try {
+        const info = {
+          iteration,
+          newIssueCount,
+          fixedIssueCount,
+          passed: passedBaseline,
+          durationMs,
+          costUsd: 0
+        };
+        const artifacts = await preserveRepairIteration(
+          worktreePath,
+          repairBaseRef,
+          taskId,
+          variantId,
+          info,
+          { modes: repairSaveModes }
+        );
+        preserved.push({ info, artifacts });
+      } catch {
+      }
+    }
+    if (config.abortIfRegression && iterations.length >= 2) {
+      const prev = iterations[iterations.length - 2];
+      const next = iterations[iterations.length - 1];
+      const hasBaselineRegression = baseline && next.newIssueCount > prev.newIssueCount;
+      const hasGateRegression = isRegression(prev.gates, next.gates);
+      const hasTestRegression = checkTestGate && baseline && next.baselineComparison && prev.baselineComparison && next.baselineComparison.delta.test.newIssues.size > prev.baselineComparison.delta.test.newIssues.size;
+      if (hasBaselineRegression || hasGateRegression || hasTestRegression) {
+        stopReason = "abort_if_regression";
+        break;
+      }
+    }
+    const effectivePassed = repairMode === "strict" ? passed : passedBaseline;
+    if (effectivePassed) {
+      stopReason = passed ? "gates_passed" : "no_new_regressions";
+      break;
+    }
+    if (iteration >= config.maxIterations) {
+      stopReason = "max_iterations_reached";
+      break;
+    }
+    if (durationMs > config.iterationTimeoutMs) {
+      stopReason = "iteration_timebox_exceeded";
+      break;
+    }
+    if (baseline && iterations.length >= 2) {
+      const prevRecord = iterations[iterations.length - 2];
+      if (prevRecord.newIssueCount === newIssueCount && newIssueCount > 0) {
+        stopReason = "no_progress";
+        break;
+      }
+    }
+    let prompt;
+    const repairAllowedFiles = mergeRepairAllowedFiles(
+      allowedFiles,
+      deriveAllowedFilesFromGateEvidence(gateRun.gates, baselineComparison)
+    );
+    if (baseline && baselineComparison) {
+      prompt = buildScopedRepairPrompt({
+        originalPrompt,
+        iteration,
+        gates: gateRun.gates,
+        constraints,
+        comparison: baselineComparison,
+        allowedFiles: repairAllowedFiles,
+        scopePolicy
+      });
+    } else {
+      prompt = buildRepairPrompt({
+        originalPrompt,
+        iteration,
+        gates: gateRun.gates,
+        constraints,
+        allowedFiles: repairAllowedFiles,
+        scopePolicy
+      });
+    }
+    const repairStart = Date.now();
+    const repairTimeoutMs = Math.max(1, config.iterationTimeoutMs);
+    const repairAbort = new AbortController();
+    let timeoutId;
+    let repairTimedOut = false;
+    const timeoutRepair = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        repairTimedOut = true;
+        repairAbort.abort();
+        reject(
+          new Error(
+            `executeRepair exceeded iteration timeout (${repairTimeoutMs}ms) at iteration ${iteration}`
+          )
+        );
+      }, repairTimeoutMs);
+      timeoutId.unref?.();
+    });
+    const repairPromise = executeRepair(prompt, iteration - 1, repairAbort.signal);
+    let repair;
+    try {
+      repair = await Promise.race([repairPromise, timeoutRepair]);
+    } catch (err) {
+      repairAbort.abort();
+      repairPromise.catch((repairErr) => {
+        if (repairTimedOut && process.env.POETIC_DEBUG_REPAIR_ABORT === "1") {
+          console.warn(
+            `[verification-loop] repair subprocess exited after abort: ${repairErr instanceof Error ? repairErr.message : String(repairErr)}`
+          );
+        }
+      });
+      stopReason = repairTimedOut ? "iteration_timebox_exceeded" : "repair_execution_failed";
+      record.durationMs = Math.max(record.durationMs, Date.now() - iterStart);
+      if (err instanceof Error) {
+        console.warn(`[verification-loop] ${err.message}`);
+      }
+      break;
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
+    const repairDuration = Date.now() - repairStart;
+    cumulativeCostUsd += Math.max(0, repair.costUsd);
+    record.costUsd = Math.max(0, repair.costUsd);
+    record.cumulativeCostUsd = cumulativeCostUsd;
+    record.durationMs = Math.max(record.durationMs, Date.now() - iterStart);
+    if (preserved.length > 0) {
+      const lastPreserved = preserved[preserved.length - 1];
+      if (lastPreserved?.info.iteration === iteration) {
+        lastPreserved.info.costUsd = record.costUsd;
+        lastPreserved.info.durationMs = record.durationMs;
+      }
+    }
+    if (Date.now() - iterStart > config.iterationTimeoutMs || repairDuration > config.iterationTimeoutMs) {
+      stopReason = "iteration_timebox_exceeded";
+      break;
+    }
+  }
+  const lastIteration = iterations.length > 0 ? iterations[iterations.length - 1] : void 0;
+  let finalPassed = lastIteration?.passed ?? false;
+  let finalPassedBaseline = lastIteration?.passedBaseline ?? false;
+  const bestChoice = findBestIteration(
+    iterations.map((it) => ({
+      iteration: it.iteration,
+      newIssueCount: it.newIssueCount,
+      fixedIssueCount: it.fixedIssueCount,
+      passed: it.passedBaseline,
+      durationMs: it.durationMs,
+      costUsd: it.costUsd
+    }))
+  );
+  bestIterationIndex = bestChoice?.index ?? 0;
+  let bestIteration = iterations[bestIterationIndex];
+  let bestIterationPromotable = bestIteration !== void 0 && (bestChoice?.iteration.passed ?? false) ? gatesHavePromotableCoverage(bestIteration.gates, checkTestGate) : false;
+  let artifactSelectionFinding;
+  let restoreFinding;
+  let repairArtifacts;
+  if (taskId && variantId && preserved.length > 0) {
+    let bestIndex = bestIteration ? preserved.findIndex((p) => p.info.iteration === bestIteration?.iteration) : -1;
+    if (bestIndex < 0) {
+      const bestPreserved = findBestIteration(preserved.map((p) => p.info));
+      bestIndex = bestPreserved?.index ?? 0;
+      const fallbackIteration = preserved[bestIndex]?.info;
+      if (fallbackIteration) {
+        const fallbackIndex = iterations.findIndex(
+          (it) => it.iteration === fallbackIteration.iteration
+        );
+        if (fallbackIndex >= 0) {
+          bestIterationIndex = fallbackIndex;
+          const selectedIteration = iterations[fallbackIndex];
+          bestIteration = selectedIteration;
+          bestIterationPromotable = fallbackIteration.passed && selectedIteration !== void 0 && gatesHavePromotableCoverage(selectedIteration.gates, checkTestGate);
+        }
+        artifactSelectionFinding = {
+          kind: "other",
+          command: "select-best-repair-artifact",
+          exitCode: 0,
+          severity: "warning",
+          outputTail: "Best verification iteration did not have preserved repair artifacts; selected the best preserved iteration instead."
+        };
+      }
+    }
+    const bestIterationInfo = preserved[bestIndex]?.info ?? preserved[0]?.info;
+    const bestArtifacts = preserved[bestIndex]?.artifacts ?? [];
+    const bestArtifactPath = bestArtifacts.find((a) => a.success)?.artifactPath;
+    repairArtifacts = {
+      taskId,
+      variantId,
+      iterations: preserved,
+      bestIterationIndex: bestIndex,
+      bestIteration: bestIterationInfo,
+      bestArtifactPath
+    };
+  }
+  const iterForFindings = bestIteration ?? lastIteration;
+  const findings = iterForFindings ? buildVerificationFindings(iterForFindings.gates, iterForFindings.passedBaseline) : [];
+  if (repairArtifacts && repairArtifacts.iterations.length > 0 && repairArtifacts.bestIteration.passed && repairArtifacts.bestIterationIndex !== repairArtifacts.iterations.length - 1) {
+    const bestArtifacts = repairArtifacts.iterations[repairArtifacts.bestIterationIndex]?.artifacts ?? [];
+    const lastArtifacts = repairArtifacts.iterations[repairArtifacts.iterations.length - 1]?.artifacts ?? [];
+    const bestPatch = bestArtifacts.find((a) => a.success && a.mode === "patch")?.artifactPath;
+    const bestRef = bestArtifacts.find(
+      (a) => a.success && (a.mode === "ref" || a.mode === "branch")
+    )?.artifactPath;
+    const lastPatch = lastArtifacts.find((a) => a.success && a.mode === "patch")?.artifactPath;
+    const lastRef = lastArtifacts.find(
+      (a) => a.success && (a.mode === "ref" || a.mode === "branch")
+    )?.artifactPath;
+    const resetToBase = async () => {
+      await execa2("git", ["reset", "--hard", repairBaseRef], {
+        cwd: worktreePath,
+        stdio: "pipe",
+        reject: false
+      });
+      await execa2("git", ["clean", "-fd"], {
+        cwd: worktreePath,
+        stdio: "pipe",
+        reject: false
+      });
+    };
+    const applyArtifact = async (patchPath, refName) => {
+      if (patchPath) {
+        const applied = await applyPatchFile(worktreePath, patchPath);
+        return applied.success;
+      }
+      if (refName) {
+        const applied = await cherryPickFromRef(worktreePath, refName);
+        return applied.success;
+      }
+      return false;
+    };
+    try {
+      await resetToBase();
+      const ok = await applyArtifact(bestPatch, bestRef);
+      if (!ok) {
+        await resetToBase();
+        const restoredLast = await applyArtifact(lastPatch, lastRef);
+        if (!restoredLast) {
+          throw new Error("failed to restore best or last repair artifact");
+        }
+      }
+    } catch (restoreError) {
+      finalPassed = false;
+      finalPassedBaseline = false;
+      bestIterationPromotable = false;
+      stopReason = "artifact_restore_failed";
+      restoreFinding = {
+        kind: "other",
+        command: "restore-best-repair-artifact",
+        exitCode: 1,
+        severity: "error",
+        outputTail: restoreError instanceof Error ? restoreError.message : String(restoreError)
+      };
+    }
+  }
+  return {
+    verification: {
+      passed: finalPassed,
+      passedBaseline: finalPassedBaseline,
+      findings: [
+        ...findings,
+        ...artifactSelectionFinding ? [artifactSelectionFinding] : [],
+        ...restoreFinding ? [restoreFinding] : []
+      ]
+    },
+    verificationLoop: {
+      enabled: true,
+      passed: finalPassed,
+      passedBaseline: finalPassedBaseline,
+      stopReason: stopReason ?? (finalPassedBaseline ? "no_new_regressions" : "gates_failed"),
+      bestIterationIndex,
+      bestIterationPromotable,
+      iterations: iterations.map((it) => ({
+        iteration: it.iteration,
+        passed: it.passed,
+        passedBaseline: it.passedBaseline,
+        newIssueCount: it.newIssueCount,
+        fixedIssueCount: it.fixedIssueCount,
+        durationMs: it.durationMs,
+        costUsd: it.costUsd,
+        cumulativeCostUsd: it.cumulativeCostUsd,
+        constraints: it.constraints,
+        build: it.gates.build,
+        lint: it.gates.lint,
+        tests: it.gates.tests
+      }))
+    },
+    repairArtifacts
+  };
+}
+
+// src/cli/variant-worker.ts
+var MIN_ANALYSIS_COMPLETENESS = 60;
+var PARTIAL_GIT_TIMEOUT_MS = 3e3;
+var SIGNAL_CLEANUP_TIMEOUT_MS = WORKER_CLEANUP_BUDGET_MS;
+var SIGNAL_CLEANUP_WRAPPER_TIMEOUT_MS = SIGNAL_CLEANUP_TIMEOUT_MS + 200;
+var POST_PROVIDER_PHASE_WARN_MS = 3e4;
+function elapsedMsSince(startTime) {
+  return Number((process.hrtime.bigint() - startTime) / 1000000n);
+}
+function addPostProviderPhaseDuration(durations, phase, durationMs) {
+  if (!Number.isFinite(durationMs) || durationMs < 0) return;
+  durations[phase] = (durations[phase] ?? 0) + Math.round(durationMs);
+}
+async function measurePostProviderPhase(durations, phase, verbose, run) {
+  const started = process.hrtime.bigint();
+  try {
+    return await run();
+  } finally {
+    const durationMs = Number((process.hrtime.bigint() - started) / 1000000n);
+    addPostProviderPhaseDuration(durations, phase, durationMs);
+    if (verbose && durationMs >= POST_PROVIDER_PHASE_WARN_MS) {
+      console.log(chalk.gray(`   post-provider phase ${phase} took ${durationMs}ms`));
+    }
+  }
+}
+function measurePostProviderPhaseSync(durations, phase, verbose, run) {
+  const started = process.hrtime.bigint();
+  try {
+    return run();
+  } finally {
+    const durationMs = Number((process.hrtime.bigint() - started) / 1000000n);
+    addPostProviderPhaseDuration(durations, phase, durationMs);
+    if (verbose && durationMs >= POST_PROVIDER_PHASE_WARN_MS) {
+      console.log(chalk.gray(`   post-provider phase ${phase} took ${durationMs}ms`));
+    }
+  }
+}
+function shouldDowngradeSuccessfulResultForShutdown(input) {
+  if (!input.shutdownRequested) return false;
+  if (input.shutdownRequestedAtMs === void 0) return true;
+  if (input.executionResultSettledAtMs === void 0) return true;
+  return input.shutdownRequestedAtMs <= input.executionResultSettledAtMs;
+}
+function activeHandleSummary() {
+  const getActiveHandles = process._getActiveHandles;
+  if (typeof getActiveHandles !== "function") return [];
+  return getActiveHandles().map((handle) => {
+    const record = handle;
+    const type = record.constructor?.name ?? typeof handle;
+    let detail;
+    if (typeof record.fd === "number") {
+      detail = `fd=${record.fd}`;
+    } else if (typeof record.path === "string") {
+      detail = record.path;
+    } else if (typeof record.address === "function") {
+      try {
+        const address = record.address();
+        detail = typeof address === "string" ? address : JSON.stringify(address);
+      } catch {
+        detail = void 0;
+      }
+    }
+    return detail ? { type, detail } : { type };
+  });
+}
+function emitWorkerLifecycleMarker(prefix, value) {
+  try {
+    const payload = typeof value === "number" ? String(value) : JSON.stringify(value);
+    process.stdout.write(`${prefix}${payload}
+`);
+  } catch {
+  }
+}
+function createProviderOutputForwarder(enabled) {
+  if (!enabled) {
+    return { close: () => {
+    } };
+  }
+  const resultStreamer = new ResultStreamer();
+  const listener = (event) => {
+    try {
+      process.stdout.write(`${PROVIDER_OUTPUT_WORKER_EVENT_PREFIX}${JSON.stringify(event)}
+`);
+    } catch {
+    }
+  };
+  const activityListener = (event) => {
+    try {
+      process.stdout.write(`${PROVIDER_ACTIVITY_WORKER_EVENT_PREFIX}${JSON.stringify(event)}
+`);
+    } catch {
+    }
+  };
+  resultStreamer.on("providerOutput", listener);
+  resultStreamer.on("providerActivity", activityListener);
+  return {
+    resultStreamer,
+    close: () => {
+      resultStreamer.off("providerOutput", listener);
+      resultStreamer.off("providerActivity", activityListener);
+      resultStreamer.close();
+    }
+  };
+}
+async function tryLoadPackageJsonScripts(repoRoot) {
+  try {
+    const raw = await fs.readFile(path.join(repoRoot, "package.json"), "utf-8");
+    const parsed = JSON.parse(raw);
+    const scripts = parsed.scripts && typeof parsed.scripts === "object" ? parsed.scripts : {};
+    return new Set(Object.keys(scripts));
+  } catch {
+    return void 0;
+  }
+}
+function extractOriginalPrompt(fullPrompt) {
+  const parts = fullPrompt.split(/\n\n---\n\n/);
+  const first = parts[0];
+  if (first?.trimStart().startsWith("[SPEC:") && parts.length > 1) {
+    return parts.slice(1).join("\n\n---\n\n").trim();
+  }
+  return (first ?? fullPrompt).trim();
+}
+function toBaselineComparisonResult(comparison) {
+  return {
+    verdict: comparison.verdict,
+    summary: comparison.summary,
+    baselineRef: comparison.baselineRef,
+    tests: {
+      newFailures: comparison.tests.newFailures,
+      fixedIssues: comparison.tests.fixedIssues,
+      persistingIssues: comparison.tests.persistingIssues
+    },
+    types: {
+      newFailures: comparison.types.newFailures,
+      fixedIssues: comparison.types.fixedIssues,
+      persistingIssues: comparison.types.persistingIssues
+    },
+    lint: {
+      newFailures: comparison.lint.newFailures,
+      fixedIssues: comparison.lint.fixedIssues,
+      persistingIssues: comparison.lint.persistingIssues
+    }
+  };
+}
+function latestVerificationIteration(loop) {
+  if (!loop?.enabled || !Array.isArray(loop.iterations) || loop.iterations.length === 0) {
+    return null;
+  }
+  return loop.iterations.reduce(
+    (best, current) => (current.iteration ?? 0) > (best.iteration ?? 0) ? current : best
+  );
+}
+function shouldTrustVerificationLoopBaseline(result) {
+  const loop = result.verificationLoop;
+  const last = latestVerificationIteration(loop);
+  if (hasVerifiedTouchedTestFailure(result) && !hasTrustworthyRepairOutcome(result)) {
+    return false;
+  }
+  return loop?.enabled === true && loop.passed === true && loop.passedBaseline === true && (last?.newIssueCount ?? 0) === 0;
+}
+function hasVerifiedTouchedTestFailure2(result) {
+  return hasVerifiedTouchedTestFailure(result);
+}
+function hasTrustworthyRepairOutcome(result) {
+  if (result.repairOutcome?.attempted !== true || result.repairOutcome.passed !== true) {
+    return false;
+  }
+  return result.repairOutcome.classification === "mechanical" || result.repairOutcome.classification === "substantive_in_scope" || result.repairOutcome.classification === "scope_expanded";
+}
+function shouldSkipRepairLoopForPassingGates(result) {
+  return (result.verificationDisposition ?? getVerificationResult(result)).outcome === "passed";
+}
+function isValidationArtifactOnlyPrompt(prompt) {
+  const hasValidationOnlyDirective = /\bvalidation(?:\s+run)?\s+only\b/i.test(prompt);
+  const hasValidationArtifactTarget = /\bvalidation\s+artifact\b/i.test(prompt) || /(?:^|[\s`"'])(?:\.poetic\/validation\/|dogfood-validation-artifacts\/)/i.test(prompt);
+  const forbidsOtherFileChanges = /\b(?:do\s+not|don't)\s+modify\s+(?:any\s+)?other\s+files\b/i.test(prompt) || /\bmodify\s+no\s+other\s+files\b/i.test(prompt);
+  return hasValidationOnlyDirective && hasValidationArtifactTarget && forbidsOtherFileChanges;
+}
+async function isValidationArtifactOnlyDiffSatisfied(input) {
+  if (!input.worktreePath || !isValidationArtifactOnlyPrompt(input.prompt)) return false;
+  try {
+    const summary = await getGitChangeSummary(input.worktreePath, input.baselineRef, true);
+    return summary.changedPaths.length > 0 && summary.changedPaths.every((changedPath) => isValidationArtifactEntry(changedPath));
+  } catch {
+    return false;
+  }
+}
+function decideRepairAdmission(input) {
+  const baseEvidence = {
+    ...input.initialVerificationOutcome ? { initialVerificationOutcome: input.initialVerificationOutcome } : {},
+    hasMissingFileTargets: input.hasMissingFileTargets,
+    isClarifyingNoOp: input.isClarifyingNoOp,
+    providerExecutionSucceeded: input.providerExecutionSucceeded,
+    hasMaterializedDeliverable: input.hasMaterializedDeliverable,
+    validationArtifactSatisfied: input.validationArtifactSatisfied,
+    filesChanged: input.filesChanged
+  };
+  if (!input.repairLoopEnabled) {
+    return {
+      action: "skip",
+      reason: "skip_disabled",
+      summary: "Repair loop disabled",
+      ...baseEvidence
+    };
+  }
+  if (input.isAnalysisIntent) {
+    return {
+      action: "skip",
+      reason: "skip_analysis_intent",
+      summary: "Skipped repair loop for analysis intent",
+      ...baseEvidence
+    };
+  }
+  if (!input.hasRetainedWorktree || !input.hasBaselineRef) {
+    return {
+      action: "skip",
+      reason: "skip_missing_worktree",
+      summary: "Skipped repair loop because retained worktree or baseline ref is unavailable",
+      ...baseEvidence
+    };
+  }
+  if (!input.providerExecutionSucceeded) {
+    return {
+      action: "skip",
+      reason: "skip_provider_failed",
+      summary: "Skipped repair loop because provider execution failed",
+      ...baseEvidence
+    };
+  }
+  if (!input.hasMaterializedDeliverable) {
+    return {
+      action: "skip",
+      reason: "skip_no_deliverable",
+      summary: "Skipped repair loop because provider produced no materialized deliverable",
+      ...baseEvidence
+    };
+  }
+  if (input.validationArtifactSatisfied === true) {
+    return {
+      action: "skip",
+      reason: "skip_validation_artifact_satisfied",
+      summary: "Skipped repair loop because validation artifact target is already satisfied",
+      ...baseEvidence
+    };
+  }
+  if (input.providerGatesAlreadyPassed) {
+    return {
+      action: "skip",
+      reason: "skip_passing_gates",
+      summary: "Skipped repair loop: provider verification already passed",
+      ...baseEvidence
+    };
+  }
+  if (input.hasMissingFileTargets && input.isClarifyingNoOp) {
+    return {
+      action: "skip",
+      reason: "skip_clarifying_noop",
+      summary: "Skipped repair loop: missing FILE targets + clarifying no-op response",
+      ...baseEvidence
+    };
+  }
+  return {
+    action: "run",
+    reason: "run_gate_failure",
+    summary: "Repair loop admitted for deterministic gate failure",
+    ...baseEvidence
+  };
+}
+function repairPolicyCompletionMode() {
+  const raw = readEnv(POETIC_COMPLETION_MODE).value;
+  return raw === "branch" || raw === "pr" || raw === "isolated" ? raw : "isolated";
+}
+function isOffScopeRepairOverrideEnabled() {
+  return readEnv(POETIC_ALLOW_OFF_SCOPE_REPAIR).value === true;
+}
+function resolveRepairPromotionPolicy(input) {
+  const outsideFiles = input.repairDelta?.filesOutsidePreRepairDiff ?? [];
+  const mechanicalFiles = new Set(input.repairDelta?.mechanicalAllowlistMatches ?? []);
+  const strictScopeExpansion = input.scopePolicy === "strict" && outsideFiles.some((file) => !mechanicalFiles.has(file));
+  const classificationForPolicy = strictScopeExpansion && input.classification !== "off_scope" ? "off_scope" : input.classification;
+  const policy = resolveRepairArtifactPolicy({
+    classification: classificationForPolicy,
+    effectiveMode: input.effectiveMode,
+    allowOffScopeRepair: input.allowOffScopeRepair
+  });
+  return strictScopeExpansion ? {
+    ...policy,
+    reason: `${policy.reason}; strict repair scope forbids non-mechanical files outside the provider diff`
+  } : policy;
+}
+function applyVerifiedTouchedTestFailureGuard(result, repairOutcome) {
+  const repairedToPassingState = (repairOutcome?.verification?.passed === true || repairOutcome?.verificationLoop?.passed === true) && hasTrustworthyRepairOutcome(result);
+  if (repairedToPassingState || !hasVerifiedTouchedTestFailure2(result)) {
+    result.verificationDisposition = getVerificationResult(result);
+    return;
+  }
+  const verificationResult = getVerificationResult(result);
+  result.verificationDisposition = verificationResult;
+}
+async function readWorktreeHeadCommit(worktreePath) {
+  const head = await execa3("git", ["rev-parse", "HEAD"], {
+    cwd: worktreePath,
+    stdio: "pipe",
+    reject: false
+  });
+  if ((head.exitCode ?? 1) !== 0) return void 0;
+  const commit = String(head.stdout ?? "").trim();
+  return commit.length > 0 ? commit : void 0;
+}
+async function captureRepairDiffSnapshot(worktreePath, baselineRef) {
+  try {
+    const [commit, diff] = await Promise.all([
+      readWorktreeHeadCommit(worktreePath),
+      captureWorktreeDiff(worktreePath, baselineRef, true)
+    ]);
+    return buildRepairDiffSnapshot(diff, commit);
+  } catch {
+    return void 0;
+  }
+}
+function buildRepairTriggerEvidence(repairOutcome) {
+  const firstIteration = repairOutcome.verificationLoop?.iterations?.[0];
+  const stopReason = typeof repairOutcome.verificationLoop?.stopReason === "string" ? repairOutcome.verificationLoop.stopReason : void 0;
+  if (!firstIteration) {
+    return {
+      type: "unknown",
+      gateId: "verification-loop",
+      summary: stopReason ? `Verification-driven repair loop recorded no iterations; stopReason=${stopReason}` : "Verification-driven repair loop recorded no iterations"
+    };
+  }
+  const failedGate = firstIteration.build?.status !== "passed" ? "build" : firstIteration.lint && firstIteration.lint.status !== "passed" ? "lint" : firstIteration.tests && firstIteration.tests.status !== "passed" ? "test" : void 0;
+  if (!failedGate) {
+    return {
+      type: "policy",
+      gateId: "verification-loop",
+      summary: stopReason ? `Verification policy ran without an initial gate failure; stopReason=${stopReason}` : "Verification policy ran without an initial gate failure"
+    };
+  }
+  const failedConstraintCheck = firstIteration.build?.command === "constraint-check" || firstIteration.lint?.command === "constraint-check" || firstIteration.tests?.command === "constraint-check";
+  if (failedConstraintCheck) {
+    return {
+      type: "policy",
+      gateId: "constraint-check",
+      summary: stopReason ? `Verification repair was triggered by policy constraint failure; stopReason=${stopReason}` : "Verification repair was triggered by policy constraint failure"
+    };
+  }
+  return {
+    type: "gate_failure",
+    gateId: failedGate,
+    summary: stopReason ? `Verification repair was triggered by initial ${failedGate} gate failure; stopReason=${stopReason}` : `Verification repair was triggered by initial ${failedGate} gate failure`
+  };
+}
+async function taskScopedChangedFiles(worktreePath, baselineRef) {
+  try {
+    const diff = await captureWorktreeDiff(worktreePath, baselineRef, true);
+    if (!diff || diff.trim().length === 0) return [];
+    return extractChangedFilesMeta(diff).map((meta) => meta.path).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function coerceComparisonGateStatus(status) {
+  switch (status) {
+    case "passed":
+    case "failed":
+    case "skipped":
+    case "timeout":
+    case "error":
+    case "unavailable":
+    case "not_run":
+      return status;
+    default:
+      return void 0;
+  }
+}
+function statusFromExitCode(exitCode) {
+  return exitCode === 0 ? "passed" : "failed";
+}
+function toGateArtifactStatus(status) {
+  return status === "not_run" ? "skipped" : status;
+}
+async function attachBaselineComparisonIfAvailable(result) {
+  const baselineRef = typeof result.baselineRef === "string" ? result.baselineRef.trim() : "";
+  if (!baselineRef) return;
+  const last = latestVerificationIteration(result.verificationLoop);
+  if (!last) return;
+  if (shouldTrustVerificationLoopBaseline(result)) {
+    result.baselineComparison = {
+      verdict: "pass",
+      baselineRef,
+      summary: {
+        totalNewFailures: 0,
+        totalFixedIssues: last.fixedIssueCount ?? 0,
+        totalPersistingIssues: 0,
+        shouldPenalize: false,
+        scoreAdjustment: 0,
+        message: "Verification loop passed baseline comparison"
+      },
+      tests: { newFailures: [], fixedIssues: [], persistingIssues: [] },
+      types: { newFailures: [], fixedIssues: [], persistingIssues: [] },
+      lint: { newFailures: [], fixedIssues: [], persistingIssues: [] }
+    };
+    return;
+  }
+  const repoRoot = process.cwd();
+  const cacheDir = path.join(repoRoot, ".poetic", "cache", "verification-baseline");
+  const changedFiles = typeof result.worktreeDiff === "string" && result.worktreeDiff.trim().length > 0 ? extractChangedFilesMeta(result.worktreeDiff).map((meta) => meta.path).filter(Boolean) : [];
+  const baseline = await getOrCaptureVerificationBaseline({
+    repoRoot,
+    baselineRef,
+    cacheDir,
+    captureOptions: { gateTimeoutMs: 6e4, changedFiles }
+  });
+  if (!baseline.metadata?.captureSucceeded) {
+    return;
+  }
+  const currentArtifacts = {
+    build: {
+      exitCode: last.build.exitCode,
+      outputTail: last.build.outputTail,
+      command: last.build.command,
+      durationMs: 0,
+      stdoutTail: "",
+      stderrTail: "",
+      language: last.build.language,
+      status: toGateArtifactStatus(
+        coerceComparisonGateStatus(last.build.status) ?? statusFromExitCode(last.build.exitCode)
+      )
+    },
+    lint: last.lint ? {
+      exitCode: last.lint.exitCode,
+      outputTail: last.lint.outputTail,
+      command: last.lint.command,
+      durationMs: 0,
+      language: last.lint.language,
+      status: toGateArtifactStatus(
+        coerceComparisonGateStatus(last.lint.status) ?? statusFromExitCode(last.lint.exitCode)
+      )
+    } : void 0,
+    tests: last.tests ? {
+      exitCode: last.tests.exitCode,
+      status: toGateArtifactStatus(
+        coerceComparisonGateStatus(last.tests.status) ?? statusFromExitCode(last.tests.exitCode)
+      ),
+      failingTests: last.tests.failingTests,
+      outputTail: last.tests.outputTail,
+      command: last.tests.command,
+      durationMs: 0,
+      language: last.tests.language
+    } : void 0
+  };
+  const currentOutcomes = verificationOutcomesFromGateArtifacts(currentArtifacts, {
+    cwd: repoRoot,
+    source: "variant-worker"
+  });
+  const stableComparison = compareVerificationOutcomeToBaseline(baseline, currentOutcomes);
+  result.baselineComparison = toBaselineComparisonResult(
+    stableComparisonToBaselineComparison(stableComparison)
+  );
+}
+async function applyRegistryDowngradeIfApplicable(result) {
+  const comparison = result.baselineComparison;
+  if (!comparison || comparison.summary.shouldPenalize !== true) return;
+  const testNewFailures = comparison.tests?.newFailures ?? [];
+  if (testNewFailures.length === 0) return;
+  if ((comparison.types?.newFailures?.length ?? 0) > 0) return;
+  if ((comparison.lint?.newFailures?.length ?? 0) > 0) return;
+  const last = latestVerificationIteration(result.verificationLoop);
+  const testOutputTail = last?.tests?.outputTail ?? "";
+  const registry = await loadKnownPreExistingFailures(process.cwd());
+  const baselineRef = (result.baselineRef ?? comparison.baselineRef)?.trim().toLowerCase();
+  const registryBaseCommit = registry.baseCommit?.trim().toLowerCase();
+  const MIN_SHA_PREFIX_LEN = 7;
+  if (!baselineRef || !registryBaseCommit || baselineRef.length < MIN_SHA_PREFIX_LEN || registryBaseCommit.length < MIN_SHA_PREFIX_LEN || !baselineRef.startsWith(registryBaseCommit) && !registryBaseCommit.startsWith(baselineRef)) {
+    return;
+  }
+  if (!allFailuresAreRegistered(testNewFailures, registry, testOutputTail)) {
+    return;
+  }
+  comparison.summary.shouldPenalize = false;
+  comparison.verdict = "neutral";
+  comparison.summary.message = [
+    comparison.summary.message,
+    `[registry] All ${testNewFailures.length} new test failure(s) matched known-pre-existing-failures registry \u2014 downgraded to baseline_clean.`
+  ].filter(Boolean).join("\n");
+  const matchedNames = testNewFailures.join(", ");
+  process.stderr.write(
+    `[poetic:registry] Downgraded shouldPenalize=true \u2192 false for ${testNewFailures.length} registered failure(s): ${matchedNames}
+`
+  );
+}
+function getWarningCodes(result) {
+  const warnings = result.warnings;
+  if (!Array.isArray(warnings)) return /* @__PURE__ */ new Set();
+  return new Set(
+    warnings.map((w) => w?.code).filter((code) => typeof code === "string" && code.trim().length > 0)
+  );
+}
+function looksLikeClarifyingQuestion(text) {
+  const lower = text.toLowerCase();
+  if (lower.includes("?")) return true;
+  return /(\bdoes(?:n't| not)\s+exist\b|\bnot\s+found\b|\bcannot\s+find\b|\bcan't\s+find\b|\bcould\s+you\s+clarify\b|\bplease\s+clarify\b|\bwhich\s+file\b|\bwhat\s+file\b)/i.test(
+    lower
+  );
+}
+initializeLabModeFromEnv("initializing-worker");
+function formatElapsedRuntime(elapsedMs) {
+  const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1e3));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes}m ${seconds}s`;
+}
+async function runWithTimeout(promise, timeoutMs, label) {
+  let timeoutHandle;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timeoutHandle = setTimeout(() => {
+          reject(new Error(`${label} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeoutHandle) {
+      clearTimeout(timeoutHandle);
+    }
+  }
+}
+function parseRepairLoopConfig() {
+  const enabledEnv = process.env.POETIC_REPAIR_LOOP_ENABLED;
+  const enabled = enabledEnv === "1";
+  const maxIterationsRaw = Number(process.env.POETIC_REPAIR_LOOP_MAX_ITERATIONS);
+  const maxIterations = Number.isFinite(maxIterationsRaw) && maxIterationsRaw > 0 ? maxIterationsRaw : DEFAULT_REPAIR_LOOP_MAX_ITERATIONS;
+  const iterationTimeoutMsRaw = Number(process.env.POETIC_REPAIR_LOOP_ITERATION_TIMEOUT_MS);
+  const iterationTimeoutMs = Number.isFinite(iterationTimeoutMsRaw) && iterationTimeoutMsRaw > 0 ? iterationTimeoutMsRaw : DEFAULT_REPAIR_LOOP_ITERATION_TIMEOUT_MS;
+  const abortIfRegression = process.env.POETIC_REPAIR_LOOP_ABORT_IF_REGRESSION !== "0";
+  const allowApiBreak = process.env.POETIC_ALLOW_API_BREAK === "1";
+  const repairModeEnv = process.env.POETIC_REPAIR_MODE;
+  const repairMode = repairModeEnv === "strict" || repairModeEnv === "none" || repairModeEnv === "auto" ? repairModeEnv : "auto";
+  const scopePolicyEnv = process.env.POETIC_REPAIR_SCOPE_POLICY;
+  const scopePolicy = scopePolicyEnv === "expand" ? "expand" : "strict";
+  const saveModesEnv = process.env.POETIC_REPAIR_SAVE_MODES;
+  const repairSaveModes = (saveModesEnv?.trim().length ? saveModesEnv : "patch").split(",").map((m) => m.trim()).filter(Boolean).filter((m) => m === "patch" || m === "ref" || m === "branch");
+  const normalizedRepairSaveModes = repairSaveModes.length > 0 ? repairSaveModes : ["patch"];
+  return {
+    enabled,
+    maxIterations,
+    iterationTimeoutMs,
+    abortIfRegression,
+    allowApiBreak,
+    repairMode,
+    scopePolicy,
+    repairSaveModes: [...normalizedRepairSaveModes]
+  };
+}
+async function tryCleanupRetainedWorktree(worktreePath, verbose) {
+  const normalized = path.resolve(worktreePath);
+  const poeticRoot = resolvePoeticRoot();
+  const allowedRoots = [
+    path.resolve(poeticRoot, ".poetic", "tmp", "worktrees"),
+    path.resolve(poeticRoot, "poetic-worktrees"),
+    path.join("/tmp", "poetic-worktrees"),
+    path.join(process.env.TMPDIR ?? "/tmp", "poetic-worktrees")
+  ];
+  const allowed = allowedRoots.some((root) => {
+    const rootWithSep = root.endsWith(path.sep) ? root : `${root}${path.sep}`;
+    return normalized === root || normalized.startsWith(rootWithSep);
+  });
+  if (!allowed) {
+    if (verbose) {
+      console.warn(
+        chalk.yellow(`Refusing to cleanup retained worktree outside known roots: ${worktreePath}`)
+      );
+    }
+    return;
+  }
+  try {
+    await execa3("git", ["worktree", "remove", "--force", normalized], {
+      cwd: poeticRoot,
+      stdio: "pipe",
+      timeout: 3e4,
+      reject: false
+    });
+  } catch (error) {
+    if (verbose) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.warn(chalk.yellow(`Failed to cleanup retained worktree: ${msg}`));
+    }
+  }
+}
+async function ensureGitMetrics(result) {
+  if (result.gitMetrics) return;
+  const worktreePath = result.retainedWorktreePath;
+  if (worktreePath) {
+    const summary = await getGitChangeSummary(worktreePath, result.baselineRef, true);
+    if (summary.filesChanged > 0) {
+      result.gitMetrics = {
+        filesChanged: summary.filesChanged,
+        linesAdded: summary.linesAdded,
+        linesDeleted: summary.linesRemoved,
+        source: summary.source === "fallback" ? "unknown" : "worktree"
+      };
+      return;
+    }
+  }
+  if (result.worktreeSummary) {
+    result.gitMetrics = {
+      filesChanged: result.worktreeSummary.filesChanged,
+      linesAdded: result.worktreeSummary.insertions,
+      linesDeleted: result.worktreeSummary.deletions,
+      source: "unknown"
+    };
+  }
+}
+function parseWorktreeListPorcelain(stdout) {
+  const entries = [];
+  let current = null;
+  const flushCurrent = () => {
+    if (current?.path) {
+      entries.push(current);
+    }
+    current = null;
+  };
+  for (const rawLine of stdout.split("\n")) {
+    const line = rawLine.trim();
+    if (line.length === 0) {
+      flushCurrent();
+      continue;
+    }
+    if (line.startsWith("worktree ")) {
+      flushCurrent();
+      current = { path: line.substring("worktree ".length).trim() };
+      continue;
+    }
+    if (line.startsWith("branch ") && current) {
+      const branch = line.substring("branch ".length).trim().replace(/^refs\/heads\//, "");
+      current.branch = branch.length > 0 ? branch : void 0;
+    }
+  }
+  flushCurrent();
+  return entries;
+}
+async function findVariantWorktreePathForTimeout(taskId, variant, repoRoot) {
+  try {
+    const listResult = await execa3("git", ["worktree", "list", "--porcelain"], {
+      cwd: repoRoot,
+      reject: false,
+      timeout: PARTIAL_GIT_TIMEOUT_MS
+    });
+    if ((listResult.exitCode ?? 0) !== 0 || !listResult.stdout?.trim()) {
+      return void 0;
+    }
+    const entries = parseWorktreeListPorcelain(listResult.stdout);
+    if (entries.length === 0) {
+      return void 0;
+    }
+    const taskToken = sanitizeRefPart(taskId, { fallback: "task", maxLen: 80 });
+    const providerToken = sanitizeRefPart(variant.provider, { fallback: "provider" });
+    const strategyToken = sanitizeRefPart(variant.strategy, { fallback: "strategy" });
+    const modeToken = sanitizeRefPart(variant.executionMode, { fallback: "mode", maxLen: 16 });
+    const branchPrefix = `poetic/var-${taskToken}-`;
+    const branchNeedle = `-${providerToken}-${strategyToken}-${modeToken}-`;
+    const matches = entries.filter((entry) => {
+      if (!entry.branch) return false;
+      return entry.branch.startsWith(branchPrefix) && entry.branch.includes(branchNeedle);
+    });
+    if (matches.length === 0) {
+      return void 0;
+    }
+    if (matches.length === 1) {
+      return matches[0]?.path;
+    }
+    const withMtime = await Promise.all(
+      matches.map(async (entry) => {
+        try {
+          const stat2 = await fs.stat(entry.path);
+          return { path: entry.path, mtimeMs: stat2.mtimeMs };
+        } catch {
+          return { path: entry.path, mtimeMs: 0 };
+        }
+      })
+    );
+    withMtime.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return withMtime[0]?.path;
+  } catch {
+    return void 0;
+  }
+}
+async function main() {
+  const program = new Command();
+  program.name("variant-worker").description("Execute a single variant task and write result to file").requiredOption("--task-id <id>", "Task identifier").requiredOption("--variant <json>", "Variant configuration as JSON string").requiredOption("--prompt-file <path>", "Path to file containing prompt text").requiredOption("--result-file <path>", "Path to write result JSON").option(
+    "--partial-result-file <path>",
+    "Path to write timeout-partial result JSON (best-effort)"
+  ).option("--timeout-minutes <minutes>", "Execution timeout in minutes", parseFloat).option(
+    "--idle-warn-minutes <minutes>",
+    "Provider idle warning threshold in minutes",
+    parseFloat
+  ).option("--idle-kill-minutes <minutes>", "Provider idle stop threshold in minutes", parseFloat).option("--verbose", "Enable verbose logging", false).action(async (options) => {
+    await executeWorker(options);
+  });
+  await program.parseAsync(process.argv);
+}
+async function warnOnce(message, state) {
+  if (state.warned) return;
+  state.warned = true;
+  console.log(chalk.yellow(message));
+}
+var RESULT_PERSISTENCE_PATH_KEYS = /* @__PURE__ */ new Set([
+  "artifactManifest",
+  "resultFile",
+  "resultPath",
+  "retainedWorktreePath",
+  "worktreePath"
+]);
+function shouldPreserveResultPersistenceString(key) {
+  return key !== void 0 && RESULT_PERSISTENCE_PATH_KEYS.has(key);
+}
+function serializeErrorForJson(error) {
+  if (error instanceof Error) {
+    const sanitized = sanitizeError(error);
+    const serialized = {
+      name: sanitized.name,
+      message: sanitized.message,
+      stack: sanitized.stack
+    };
+    if (error instanceof ProviderExecutionError) {
+      serialized.code = error.code;
+      serialized.reason = sanitizeSynthesisArtifactForPersistence(error.reason);
+      serialized.retryable = error.retryable;
+      serialized.exitCode = error.exitCode;
+      serialized.statusCode = error.statusCode;
+      serialized.idleTerminated = error.idleTerminated;
+      serialized.signal = sanitizeSynthesisArtifactForPersistence(error.signal);
+      serialized.terminationSource = sanitizeSynthesisArtifactForPersistence(
+        error.terminationSource
+      );
+      serialized.context = sanitizeSynthesisArtifactForPersistence(error.context);
+      serialized.parsedError = sanitizeSynthesisArtifactForPersistence(error.parsedError);
+    }
+    return serialized;
+  }
+  return sanitizeSynthesisArtifactForPersistence(error);
+}
+function sanitizeResultPayloadForJson(value, seen = /* @__PURE__ */ new WeakSet(), key = void 0) {
+  if (value instanceof Error) {
+    return serializeErrorForJson(value);
+  }
+  if (typeof value === "string") {
+    return shouldPreserveResultPersistenceString(key) ? value : sanitizeSynthesisStringForPersistence(value);
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (typeof value === "boolean" || value === null) {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "symbol" || typeof value === "function" || value === void 0) {
+    return void 0;
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (seen.has(value)) {
+    return "[Circular]";
+  }
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      return value.map((entry) => sanitizeResultPayloadForJson(entry, seen, key));
+    }
+    const sanitized = {};
+    for (const [entryKey, entry] of Object.entries(value)) {
+      const sanitizedEntry = entryKey === "error" ? serializeErrorForJson(entry) : sanitizeResultPayloadForJson(entry, seen, entryKey);
+      const finalValue = isSensitiveKey(entryKey) ? "[REDACTED]" : sanitizedEntry;
+      if (finalValue !== void 0) {
+        sanitized[entryKey] = finalValue;
+      }
+    }
+    return sanitized;
+  } finally {
+    seen.delete(value);
+  }
+}
+async function writeResultFileAtomically(resultPath, payload) {
+  const resultJson = JSON.stringify(sanitizeResultPayloadForJson(payload), null, 2);
+  const tmpFile = `${resultPath}.tmp.${randomBytes(4).toString("hex")}`;
+  await fs.writeFile(tmpFile, resultJson, "utf-8");
+  const fd = openSync(tmpFile, "r+");
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  await fs.rename(tmpFile, resultPath);
+}
+var __testOnlyWriteResultFileAtomically = writeResultFileAtomically;
+function formatVerboseWorkerCompletionMetric(variant, result) {
+  if (variant.strategy === "fusion") {
+    return `Contribution: ${result.success ? "completed" : "not completed"}`;
+  }
+  return `Completeness: ${result.completeness.toFixed(1)}%`;
+}
+async function executeWorker(options) {
+  const {
+    taskId,
+    variant: variantJson,
+    promptFile,
+    resultFile,
+    timeoutMinutes,
+    idleWarnMinutes,
+    idleKillMinutes,
+    verbose
+  } = options;
+  const repairLoopConfig = parseRepairLoopConfig();
+  if (idleWarnMinutes == null !== (idleKillMinutes == null)) {
+    throw new Error("--idle-warn-minutes and --idle-kill-minutes must be provided together");
+  }
+  initializeLabModeFromEnv(taskId);
+  if (verbose) {
+    console.log(chalk.blue("Variant Worker starting"));
+    console.log(chalk.gray(`   Task ID: ${taskId}`));
+    console.log(chalk.gray(`   Prompt: ${promptFile}`));
+    console.log(chalk.gray(`   Result: ${resultFile}`));
+    console.log(
+      chalk.gray(`   Partial Result: ${options.partialResultFile ?? `${resultFile}.partial.json`}`)
+    );
+  }
+  let variant;
+  try {
+    variant = parseJsonWithContext(
+      variantJson,
+      "[Variant Worker] variant configuration"
+    );
+  } catch (error) {
+    throw new Error(
+      `Invalid variant JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const workerProcessLifecycle = new ProcessLifecycleManager({
+    verbose: verbose === true,
+    defaultTimeoutMinutes: timeoutMinutes ?? DEFAULT_PER_VARIANT_TIMEOUT_MINUTES,
+    maxConcurrentProcesses: 10,
+    cleanupOnTermination: true
+  });
+  setProcessLifecycleManager(workerProcessLifecycle);
+  const processLifecycleSignalHandlerName = "variant-worker-process-lifecycle";
+  const signalHandlerName = "variant-worker-timeout-partial-result";
+  let postProviderSignalHandlersInstalled = false;
+  const onPostProviderSigterm = () => {
+    void postProviderShutdown?.("SIGTERM");
+  };
+  const onPostProviderSigint = () => {
+    void postProviderShutdown?.("SIGINT");
+  };
+  let postProviderShutdown;
+  const installPostProviderSignalHandlers = () => {
+    if (postProviderSignalHandlersInstalled) return;
+    signalCoordinator.suspendProcessSignalHandlers();
+    process.on("SIGTERM", onPostProviderSigterm);
+    process.on("SIGINT", onPostProviderSigint);
+    postProviderSignalHandlersInstalled = true;
+  };
+  const uninstallPostProviderSignalHandlers = () => {
+    if (!postProviderSignalHandlersInstalled) return;
+    process.removeListener("SIGTERM", onPostProviderSigterm);
+    process.removeListener("SIGINT", onPostProviderSigint);
+    signalCoordinator.resumeProcessSignalHandlers();
+    postProviderSignalHandlersInstalled = false;
+  };
+  signalCoordinator.register(
+    processLifecycleSignalHandlerName,
+    async (context) => {
+      if (context.reason === "SIGTERM" || context.reason === "SIGINT") {
+        await workerProcessLifecycle.handleSignal(context.reason);
+        return;
+      }
+      await workerProcessLifecycle.close();
+    },
+    { priority: "critical", phase: "process-termination" }
+  );
+  try {
+    variant.nativeWebSearch = isNativeResearchEnabledFor(variant.provider);
+    const runMode = variant.isBasicCompetition ? "basic-cli-native" : "advanced";
+    const partialResultFile = typeof options.partialResultFile === "string" && options.partialResultFile.trim().length > 0 ? options.partialResultFile.trim() : `${resultFile}.partial.json`;
+    const workerStartMs = Date.now();
+    const startTime = process.hrtime.bigint();
+    const timeoutContext = {};
+    let executorSettled = false;
+    const persistTimeoutPartialResult = async () => {
+      const timeoutWorktreeCandidate = timeoutContext.worktreePath ?? variant.workflowWorktreePath;
+      let timeoutWorktreePath = typeof timeoutWorktreeCandidate === "string" && timeoutWorktreeCandidate.trim().length > 0 ? timeoutWorktreeCandidate.trim() : void 0;
+      if (!timeoutWorktreePath) {
+        timeoutWorktreePath = await findVariantWorktreePathForTimeout(
+          taskId,
+          variant,
+          process.cwd()
+        );
+        if (!timeoutWorktreePath && verbose) {
+          console.warn("[partial-save] Worktree context unavailable; needle discovery also failed");
+        }
+      }
+      const elapsedText = formatElapsedRuntime(Date.now() - workerStartMs);
+      let filesChanged = 0;
+      let linesAdded = 0;
+      let linesRemoved = 0;
+      let statusLines = [];
+      let partialEdits = false;
+      let autoCommitFailed = false;
+      let worktreeDiff;
+      let baselineRef = typeof timeoutContext.baselineRef === "string" && timeoutContext.baselineRef.trim().length > 0 ? timeoutContext.baselineRef.trim() : void 0;
+      let partialErrorDetail;
+      if (timeoutWorktreePath) {
+        try {
+          const canMutateWorktreeForSnapshot = executorSettled;
+          if (canMutateWorktreeForSnapshot) {
+            await execa3("git", ["add", "-A"], {
+              cwd: timeoutWorktreePath,
+              stdio: "pipe",
+              reject: false,
+              timeout: 1200
+            });
+          } else {
+            partialErrorDetail = "executor still running during timeout; skipped git add/commit partial snapshot";
+          }
+          const [cachedStat, cachedShortStat, statusResult] = await Promise.all([
+            execa3(
+              "git",
+              canMutateWorktreeForSnapshot ? ["diff", "--cached", "--stat"] : ["diff", "--stat"],
+              {
+                cwd: timeoutWorktreePath,
+                stdio: "pipe",
+                reject: false,
+                timeout: 1200
+              }
+            ),
+            execa3(
+              "git",
+              canMutateWorktreeForSnapshot ? ["diff", "--cached", "--shortstat"] : ["diff", "--shortstat"],
+              {
+                cwd: timeoutWorktreePath,
+                stdio: "pipe",
+                reject: false,
+                timeout: 1200
+              }
+            ),
+            execa3("git", ["status", "--porcelain", "--untracked-files=all"], {
+              cwd: timeoutWorktreePath,
+              stdio: "pipe",
+              reject: false,
+              timeout: 1200
+            })
+          ]);
+          partialEdits = cachedStat.stdout.trim().length > 0;
+          const parsedShortStat = parseShortStatSummary(cachedShortStat.stdout);
+          filesChanged = parsedShortStat.filesChanged;
+          linesAdded = parsedShortStat.linesAdded;
+          linesRemoved = parsedShortStat.linesRemoved;
+          statusLines = statusResult.stdout.split("\n").map((line) => line.trimEnd()).filter((line) => line.trim().length > 0);
+          if (partialEdits && filesChanged === 0 && statusLines.length > 0) {
+            filesChanged = statusLines.length;
+          }
+          if (partialEdits && canMutateWorktreeForSnapshot) {
+            const commitMessage = `chore: partial work (timeout at ${elapsedText})`;
+            const commit = await execa3("git", ["commit", "--no-verify", "-m", commitMessage], {
+              cwd: timeoutWorktreePath,
+              stdio: "pipe",
+              reject: false,
+              timeout: 1500
+            });
+            autoCommitFailed = (commit.exitCode ?? 0) !== 0;
+            if (!autoCommitFailed && !baselineRef) {
+              const parent = await execa3("git", ["rev-parse", "HEAD~1"], {
+                cwd: timeoutWorktreePath,
+                stdio: "pipe",
+                reject: false,
+                timeout: 1200
+              });
+              if ((parent.exitCode ?? 0) === 0 && parent.stdout.trim().length > 0) {
+                baselineRef = parent.stdout.trim();
+              }
+            }
+            try {
+              const diffText = await captureWorktreeDiff(timeoutWorktreePath, baselineRef, true);
+              if (diffText.trim().length > 0) {
+                worktreeDiff = normalizeWorktreeDiff(diffText);
+              }
+            } catch {
+            }
+          }
+        } catch (error) {
+          partialErrorDetail = error instanceof Error ? error.message : String(error);
+        }
+      }
+      if (!partialErrorDetail && partialEdits) {
+        if (autoCommitFailed) {
+          partialErrorDetail = "auto-commit failed";
+        }
+      }
+      const completeness = partialEdits ? estimateTimeoutCompletenessFromScope({
+        filesChanged,
+        linesAdded,
+        linesRemoved,
+        statusEntries: statusLines.length
+      }) : 0;
+      const timeoutErrorMessage = (() => {
+        if (partialErrorDetail) {
+          if (partialEdits && !autoCommitFailed) {
+            return `Timed out at ${elapsedText}; partial edits detected (preservation warning: ${partialErrorDetail})`;
+          }
+          if (partialEdits && autoCommitFailed) {
+            return `Timed out at ${elapsedText}; partial edits detected but auto-commit failed`;
+          }
+          return `Timed out at ${elapsedText}; partial preservation warning: ${partialErrorDetail}`;
+        }
+        if (partialEdits) {
+          return `Timed out at ${elapsedText}; partial edits preserved`;
+        }
+        return `Timed out at ${elapsedText}; no staged edits detected`;
+      })();
+      const partialResult = {
+        variant: formatVariantIdentifier(variant),
+        provider: variant.provider,
+        model: variant.model,
+        strategy: variant.strategy,
+        executionMode: variant.executionMode,
+        success: false,
+        duration: Number(process.hrtime.bigint() - startTime) / 1e9,
+        completeness,
+        timedOut: true,
+        partialEdits,
+        terminationReason: "timeout",
+        executionIntent: variant.executionIntent,
+        isBasicCompetition: variant.isBasicCompetition,
+        emptyChanges: !partialEdits,
+        filesChanged,
+        linesAdded,
+        linesRemoved,
+        worktreeDiff,
+        gitMetrics: partialEdits ? {
+          filesChanged,
+          linesAdded,
+          linesDeleted: linesRemoved,
+          source: "worktree"
+        } : void 0,
+        worktreeSummary: timeoutWorktreePath ? {
+          filesChanged,
+          insertions: linesAdded,
+          deletions: linesRemoved,
+          statusLines
+        } : void 0,
+        retainedWorktreePath: timeoutWorktreePath,
+        baselineRef,
+        error: new Error(timeoutErrorMessage)
+      };
+      partialResult.outcome = deriveVariantOutcome(partialResult);
+      sanitizeVariantResult(partialResult);
+      await writeResultFileAtomically(partialResultFile, partialResult);
+    };
+    const executionAbortController = new AbortController();
+    let shutdownRequested = false;
+    let shutdownRequestedAtMs;
+    let shutdownSignal;
+    const signalExitCode = (signal) => signal === "SIGINT" ? 130 : 143;
+    const requestShutdown = async (signal, options2) => {
+      if (shutdownRequested) {
+        return;
+      }
+      shutdownRequested = true;
+      shutdownRequestedAtMs = elapsedMsSince(startTime);
+      shutdownSignal = signal;
+      if (signal === "SIGINT") {
+        mergeExecutionContextEnvOverrides({ POETIC_PRESERVE_WORKTREES: "1" });
+      }
+      if (!executionAbortController.signal.aborted) {
+        executionAbortController.abort(new Error(`Variant worker received ${signal}`));
+      }
+      const exitAfter = options2?.exitAfter ?? true;
+      try {
+        if (verbose) {
+          console.log(chalk.yellow(`Received ${signal}; beginning timeout shutdown handling.`));
+        }
+        if (signal === "SIGTERM") {
+          try {
+            await runWithTimeout(persistTimeoutPartialResult(), 2500, "partial timeout save");
+            if (verbose) {
+              console.log(chalk.gray(`   Partial timeout result written to ${partialResultFile}`));
+            }
+          } catch (error) {
+            if (verbose) {
+              const message = error instanceof Error ? error.message : String(error);
+              console.warn(chalk.yellow(`Partial timeout preservation skipped: ${message}`));
+            }
+          }
+        }
+        if (exitAfter) {
+          try {
+            await runWithTimeout(
+              signalCoordinator.runCleanupHandlers(`variant-worker ${signal.toLowerCase()}`, {
+                timeoutMs: SIGNAL_CLEANUP_TIMEOUT_MS
+              }),
+              SIGNAL_CLEANUP_WRAPPER_TIMEOUT_MS,
+              "signal cleanup"
+            );
+          } catch {
+          }
+        }
+      } catch (shutdownError) {
+        console.error(
+          `[variant-worker] Shutdown error (${signal}): ${shutdownError instanceof Error ? shutdownError.message : String(shutdownError)}`
+        );
+      } finally {
+        if (exitAfter) {
+          process.exit(signalExitCode(signal));
+        }
+      }
+    };
+    postProviderShutdown = async (signal) => {
+      await requestShutdown(signal, { exitAfter: false });
+    };
+    signalCoordinator.register(
+      signalHandlerName,
+      async (context) => {
+        if (context.reason === "SIGTERM" || context.reason === "SIGINT") {
+          await requestShutdown(context.reason, { exitAfter: false });
+        }
+      },
+      { priority: "critical", phase: "artifact-cleanup" }
+    );
+    if (variant.executionMode !== "local") {
+      throw new Error(`Worker only supports local execution mode (got: ${variant.executionMode})`);
+    }
+    let prompt;
+    try {
+      prompt = await fs.readFile(promptFile, "utf-8");
+    } catch (error) {
+      throw new Error(
+        `Failed to read prompt file: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    if (verbose) {
+      console.log(chalk.blue(`Loaded prompt (${prompt.length} chars)`));
+      console.log(chalk.blue(`Executing ${variant.provider} ${variant.strategy}...`));
+    }
+    const repoRoot = process.cwd();
+    const packageJsonScripts = await tryLoadPackageJsonScripts(repoRoot);
+    const originalPrompt = getRuntimeEnv("POETIC_ORIGINAL_TASK_DESCRIPTION") ?? extractOriginalPrompt(prompt);
+    const specInjectionUsed = /\[SPEC:/.test(prompt);
+    const specSignal = evaluateExecutionSpec(originalPrompt);
+    let guidanceTier;
+    let specQualitySignals;
+    if (specSignal) {
+      guidanceTier = specSignal.guidanceTier;
+      specQualitySignals = generateSpecQualitySignals(originalPrompt, repoRoot, packageJsonScripts);
+    }
+    const classification = classifyTask(prompt, { stripInjections: true });
+    let telemetry = null;
+    let telemetryEnabled = true;
+    const telemetryWarning = { warned: false };
+    const costTrackerWarning = { warned: false };
+    const applyWorkerEnvOverrides = (overrides) => {
+      mergeExecutionContextEnvOverrides(overrides);
+    };
+    const prevRetainBasicWorktree = getRuntimeEnv("POETIC_RETAIN_BASIC_WORKTREE");
+    const prevPreserveWorktrees = getRuntimeEnv("POETIC_PRESERVE_WORKTREES");
+    const preserveWorktreesForDebug = prevRetainBasicWorktree === "1" && getRuntimeEnv("POETIC_PRESERVE_WORKTREES") !== "1";
+    if (preserveWorktreesForDebug) {
+      applyWorkerEnvOverrides({ POETIC_PRESERVE_WORKTREES: "1" });
+    }
+    try {
+      telemetry = TelemetryLogger.getInstance();
+      telemetry.logVariantEvent(taskId, formatVariantIdentifier(variant), "started", {
+        provider: variant.provider,
+        model: variant.model,
+        executionMode: variant.executionMode,
+        strategy: variant.strategy,
+        runMode,
+        executionIntent: variant.executionIntent,
+        ...typeof guidanceTier === "number" ? { guidanceTier } : {},
+        ...specInjectionUsed ? { specInjectionUsed: true } : {},
+        ...Array.isArray(specQualitySignals) && specQualitySignals.length > 0 ? { specQualitySignals } : {},
+        ...classification.drift ? { classificationDrift: classification.drift } : {}
+      });
+    } catch (_err) {
+      await warnOnce(
+        "Telemetry unavailable for worker; continuing with JSON output only.",
+        telemetryWarning
+      );
+      telemetryEnabled = false;
+    }
+    let result;
+    let cleanupWorktreeAfterRun = false;
+    let executionResultSettledAtMs;
+    const providerOutputForwarder = createProviderOutputForwarder(
+      getRuntimeEnv("POETIC_PROVIDER_OUTPUT_EVENTS") === "1"
+    );
+    try {
+      const { GitHubPRManager } = await import("./github-pr-manager-4LXEKJTA.js");
+      const { LocalExecutor } = await import("./local-executor-CEHWE2PL.js");
+      if (repairLoopConfig.enabled && prevRetainBasicWorktree === void 0 && getRuntimeEnv("POETIC_RETAIN_BASIC_WORKTREE") !== "1") {
+        applyWorkerEnvOverrides({ POETIC_RETAIN_BASIC_WORKTREE: "1" });
+        cleanupWorktreeAfterRun = getRuntimeEnv("POETIC_PRESERVE_WORKTREES") !== "1";
+      }
+      let costTracker;
+      if (telemetry) {
+        try {
+          const { UnifiedCostTracker } = await import("./unified-cost-tracker-4TFRBVPR.js");
+          const { UniversalCostCalculator } = await import("./universal-cost-calculator-BAJV35GA.js");
+          const costCalculator = new UniversalCostCalculator(telemetry);
+          costTracker = new UnifiedCostTracker(costCalculator, telemetry, {
+            enabled: true,
+            budgetThresholds: {
+              warning: 1,
+              critical: 5,
+              daily: 10,
+              monthly: 100
+            },
+            optimization: {
+              enableSuggestions: false,
+              minSavingsThreshold: 1,
+              maxSuggestionsPerHour: 0
+            },
+            updateIntervalMs: 6e4
+          });
+        } catch (costErr) {
+          await warnOnce(
+            "Cost tracking initialization failed in worker; continuing without a UnifiedCostTracker.",
+            costTrackerWarning
+          );
+          if (verbose) {
+            const message = costErr instanceof Error ? costErr.message : String(costErr);
+            console.warn(chalk.yellow(`   Cost tracking init error: ${message}`));
+          }
+        }
+      }
+      const prManager = new GitHubPRManager();
+      const executor = new LocalExecutor({
+        prManager,
+        repoRoot,
+        verbose: verbose ?? false,
+        executorTimeoutMs: timeoutMinutes != null ? timeoutMinutes * 6e4 : void 0,
+        idleWarnMs: idleWarnMinutes != null ? idleWarnMinutes * 6e4 : void 0,
+        idleKillMs: idleKillMinutes != null ? idleKillMinutes * 6e4 : void 0,
+        costTracker,
+        resultStreamer: providerOutputForwarder.resultStreamer,
+        onWorktreeReady: ({ worktreePath, baselineRef }) => {
+          timeoutContext.worktreePath = worktreePath;
+          timeoutContext.baselineRef = baselineRef;
+        }
+      });
+      const executionBreadcrumb = createCliBreadcrumb({
+        label: `Variant ${variant.provider}:${variant.strategy}`,
+        detail: "execution started; this step can stay quiet while the provider works."
+      });
+      let execResult;
+      try {
+        execResult = await executor.executeVariant(taskId, variant, prompt, {
+          abortSignal: executionAbortController.signal
+        });
+        executionResultSettledAtMs = elapsedMsSince(startTime);
+        installPostProviderSignalHandlers();
+        executionBreadcrumb.complete();
+      } finally {
+        executorSettled = true;
+        executionBreadcrumb.dispose();
+      }
+      result = execResult;
+      const postProviderPhaseDurationsMs = {};
+      result.postProviderPhaseDurationsMs = postProviderPhaseDurationsMs;
+      timeoutContext.worktreePath = result.retainedWorktreePath ?? timeoutContext.worktreePath;
+      timeoutContext.baselineRef = result.baselineRef ?? timeoutContext.baselineRef;
+      measurePostProviderPhaseSync(
+        postProviderPhaseDurationsMs,
+        "resultNormalization",
+        verbose,
+        () => {
+          if (variant.executionIntent === "analysis" && result.success !== false && (result.completeness ?? 0) < MIN_ANALYSIS_COMPLETENESS) {
+            const boosted = Math.max(result.completeness ?? 0, MIN_ANALYSIS_COMPLETENESS);
+            result.completeness = boosted;
+            result.completenessScore = {
+              score: boosted,
+              category: "analysis",
+              fileTargetMatchRate: result.completenessScore?.fileTargetMatchRate
+            };
+          }
+          if (result.completeness < 0) {
+            result.completeness = 0;
+          }
+        }
+      );
+      const duration = Number(process.hrtime.bigint() - startTime) / 1e9;
+      result.executionDurationMs = Math.round(duration * 1e3);
+      await measurePostProviderPhase(
+        postProviderPhaseDurationsMs,
+        "gitMetrics",
+        verbose,
+        async () => ensureGitMetrics(result)
+      );
+      const isAnalysisIntent = variant.executionIntent === "analysis";
+      let repairOutcomeForGuards = null;
+      const hasRetainedRepairWorktree = typeof result.retainedWorktreePath === "string" && result.retainedWorktreePath.trim().length > 0;
+      const hasRepairBaselineRef = typeof result.baselineRef === "string" && result.baselineRef.trim().length > 0;
+      const warningCodes = getWarningCodes(result);
+      const hasMissingFileTargets = warningCodes.has("WS-008");
+      const filesChanged = result.gitMetrics?.filesChanged ?? result.filesChanged ?? 0;
+      const hasMaterializedDeliverable = filesChanged > 0 || result.outcome?.delivery?.hasChanges === true;
+      const outputText = `${result.result?.stdout ?? ""}
+${result.result?.stderr ?? ""}`;
+      const isClarifyingNoOp = filesChanged === 0 && looksLikeClarifyingQuestion(outputText);
+      const initialVerificationDisposition = result.verificationDisposition ?? getVerificationResult(result);
+      const providerGatesAlreadyPassed = initialVerificationDisposition.outcome === "passed";
+      const exactArtifactGate = await measurePostProviderPhase(
+        postProviderPhaseDurationsMs,
+        "exactArtifactGoalGate",
+        verbose,
+        async () => {
+          if (!hasRetainedRepairWorktree) {
+            return { success: result.success === true };
+          }
+          return applyExactArtifactGoalSuccessGate({
+            prompt,
+            worktreePath: result.retainedWorktreePath,
+            success: result.success === true
+          });
+        }
+      );
+      if (result.success === true && !exactArtifactGate.success) {
+        result.success = false;
+        result.completeness = 0;
+        result.error = new Error(
+          exactArtifactGate.failureReason ?? "Exact artifact content mismatch"
+        );
+      }
+      const validationArtifactSatisfied = await measurePostProviderPhase(
+        postProviderPhaseDurationsMs,
+        "validationArtifactCheck",
+        verbose,
+        async () => {
+          if (!hasRetainedRepairWorktree || result.success !== true) return false;
+          const simpleArtifactGoal = parseSimpleArtifactGoal(prompt);
+          if (simpleArtifactGoal) {
+            return isSimpleArtifactGoalSatisfied(result.retainedWorktreePath, simpleArtifactGoal);
+          }
+          return isValidationArtifactOnlyDiffSatisfied({
+            prompt,
+            worktreePath: result.retainedWorktreePath,
+            baselineRef: result.baselineRef
+          });
+        }
+      );
+      const repairAdmission = measurePostProviderPhaseSync(
+        postProviderPhaseDurationsMs,
+        "repairAdmission",
+        verbose,
+        () => {
+          return decideRepairAdmission({
+            repairLoopEnabled: repairLoopConfig.enabled,
+            isAnalysisIntent,
+            hasRetainedWorktree: hasRetainedRepairWorktree,
+            hasBaselineRef: hasRepairBaselineRef,
+            initialVerificationOutcome: initialVerificationDisposition.outcome,
+            providerGatesAlreadyPassed,
+            hasMissingFileTargets,
+            isClarifyingNoOp,
+            providerExecutionSucceeded: result.success === true,
+            hasMaterializedDeliverable,
+            validationArtifactSatisfied,
+            filesChanged
+          });
+        }
+      );
+      result.repairAdmission = repairAdmission;
+      if (repairLoopConfig.enabled && result.repairAdmission.action === "skip" && (result.repairAdmission.reason === "skip_passing_gates" || result.repairAdmission.reason === "skip_clarifying_noop")) {
+        emitWarning(
+          "PERF-003",
+          {
+            taskId,
+            subsystem: "repair-loop",
+            executionPhase: "validation"
+          },
+          {
+            metadata: {
+              reason: result.repairAdmission.summary,
+              admissionReason: result.repairAdmission.reason
+            }
+          }
+        );
+      }
+      if (result.repairAdmission.action === "run") {
+        let repairOutcome = null;
+        let preRepairDiffSnapshot;
+        {
+          const worktreePath = result.retainedWorktreePath;
+          const baselineRef = result.baselineRef;
+          const initialCostUsd = result.costMetrics?.totalCost ?? result.result?.totalCostUsd ?? 0;
+          preRepairDiffSnapshot = await measurePostProviderPhase(
+            postProviderPhaseDurationsMs,
+            "preRepairDiffSnapshot",
+            verbose,
+            async () => captureRepairDiffSnapshot(worktreePath, baselineRef)
+          );
+          if (!preRepairDiffSnapshot) {
+            emitWarning(
+              "PERF-003",
+              {
+                taskId,
+                subsystem: "repair-loop",
+                executionPhase: "validation"
+              },
+              {
+                metadata: {
+                  reason: "pre-repair diff snapshot unavailable; repair-scope classification will be unknown",
+                  baselineRef,
+                  worktreePath
+                }
+              }
+            );
+          }
+          const repoRoot2 = process.cwd();
+          const cacheDir = path.join(repoRoot2, ".poetic", "cache", "verification-baseline");
+          const repairChangedFiles = await taskScopedChangedFiles(worktreePath, baselineRef);
+          const baselineForRepair = await measurePostProviderPhase(
+            postProviderPhaseDurationsMs,
+            "verificationBaselineCapture",
+            verbose,
+            async () => getOrCaptureVerificationBaseline({
+              repoRoot: repoRoot2,
+              baselineRef,
+              cacheDir,
+              captureOptions: { gateTimeoutMs: 6e4, changedFiles: repairChangedFiles }
+            }).catch(() => null)
+          );
+          const baselineSucceeded = !!baselineForRepair?.metadata?.captureSucceeded;
+          const allowedFiles = (() => {
+            try {
+              const spec = parsePromptSpec(prompt);
+              return Array.isArray(spec.fileConstraint.targets) ? spec.fileConstraint.targets : [];
+            } catch {
+              return [];
+            }
+          })();
+          repairOutcome = await measurePostProviderPhase(
+            postProviderPhaseDurationsMs,
+            "repairLoop",
+            verbose,
+            async () => runVerificationDrivenRepairLoop({
+              config: {
+                enabled: true,
+                maxIterations: Math.max(1, Math.floor(repairLoopConfig.maxIterations)),
+                iterationTimeoutMs: Math.max(
+                  1e3,
+                  Math.floor(repairLoopConfig.iterationTimeoutMs)
+                ),
+                abortIfRegression: repairLoopConfig.abortIfRegression,
+                allowApiBreak: repairLoopConfig.allowApiBreak,
+                repairMode: repairLoopConfig.repairMode,
+                scopePolicy: repairLoopConfig.scopePolicy,
+                repairSaveModes: repairLoopConfig.repairSaveModes,
+                allowedFiles,
+                // Default to true for software-aware judges (Hybrid, Multi-lens).
+                // This enables test failure detection in regression checks.
+                checkTestGate: true
+              },
+              worktreePath,
+              baselineRef,
+              baseline: baselineSucceeded ? baselineForRepair : void 0,
+              taskId,
+              variantId: formatVariantIdentifier(variant),
+              originalPrompt: prompt,
+              initialCostUsd: Number.isFinite(initialCostUsd) && initialCostUsd > 0 ? initialCostUsd : 0,
+              executeRepair: async (repairPrompt, iterationIndex, abortSignal) => {
+                const repairTaskId = `${taskId}-verify-${iterationIndex + 1}`;
+                const repairVariant = {
+                  ...variant,
+                  // Enforce same worktree + prevent auto-commit drift during repair loops.
+                  workflowWorktreePath: worktreePath,
+                  disableAutoCommit: true,
+                  isBasicCompetition: true
+                };
+                const repairResult = await executor.executeVariant(
+                  repairTaskId,
+                  repairVariant,
+                  repairPrompt,
+                  { abortSignal }
+                );
+                const costUsd = repairResult.costMetrics?.totalCost ?? repairResult.result?.totalCostUsd ?? 0;
+                return { costUsd: Number.isFinite(costUsd) ? costUsd : 0 };
+              }
+            })
+          );
+          repairOutcomeForGuards = repairOutcome;
+          result.verification = repairOutcome.verification;
+          result.verificationLoop = repairOutcome.verificationLoop;
+        }
+        if (repairOutcome) {
+          const { verificationLoop } = repairOutcome;
+          const shouldPromoteRepairs = verificationLoop.iterations.length > 0 && verificationLoop.bestIterationPromotable;
+          if (!shouldPromoteRepairs) {
+          } else {
+            cleanupWorktreeAfterRun = false;
+            try {
+              const worktreePath = result.retainedWorktreePath;
+              const baselineRef = result.baselineRef;
+              const iterCount = verificationLoop.iterations.length;
+              let commitSucceeded = false;
+              const status = await measurePostProviderPhase(
+                postProviderPhaseDurationsMs,
+                "repairPromotionStatus",
+                verbose,
+                async () => execa3("git", ["status", "--porcelain"], {
+                  cwd: worktreePath,
+                  stdio: "pipe",
+                  reject: false
+                })
+              );
+              const isDirty = String(status.stdout ?? "").trim().length > 0;
+              const repairedSummary = await measurePostProviderPhase(
+                postProviderPhaseDurationsMs,
+                "repairPromotionChangeSummary",
+                verbose,
+                async () => getGitChangeSummary(worktreePath, baselineRef, true)
+              );
+              const finalDiffSnapshot = await measurePostProviderPhase(
+                postProviderPhaseDurationsMs,
+                "repairPromotionDiffSnapshot",
+                verbose,
+                async () => captureRepairDiffSnapshot(worktreePath, baselineRef)
+              );
+              if (!finalDiffSnapshot) {
+                emitWarning(
+                  "PERF-003",
+                  {
+                    taskId,
+                    subsystem: "repair-loop",
+                    executionPhase: "validation"
+                  },
+                  {
+                    metadata: {
+                      reason: "post-repair diff snapshot unavailable; repair-scope classification will be unknown",
+                      baselineRef,
+                      worktreePath
+                    }
+                  }
+                );
+              }
+              const repairScopeAnalysis = analyzeRepairScope({
+                preRepairDiff: preRepairDiffSnapshot,
+                finalDiff: finalDiffSnapshot
+              });
+              const repairPolicy = resolveRepairPromotionPolicy({
+                classification: repairScopeAnalysis.classification,
+                repairDelta: repairScopeAnalysis.repairDelta,
+                scopePolicy: repairLoopConfig.scopePolicy,
+                effectiveMode: repairPolicyCompletionMode(),
+                allowOffScopeRepair: isOffScopeRepairOverrideEnabled()
+              });
+              const allowRepairCommit = repairPolicy.action === "allow" || repairPolicy.action === "warn";
+              if (isDirty && !allowRepairCommit) {
+                emitWarning(
+                  "PERF-003",
+                  {
+                    taskId,
+                    subsystem: "repair-loop",
+                    executionPhase: "validation"
+                  },
+                  {
+                    metadata: {
+                      reason: `Skipped repair commit: ${repairPolicy.reason}`,
+                      policyAction: repairPolicy.action,
+                      classification: repairScopeAnalysis.classification,
+                      finalArtifactTrust: repairPolicy.finalArtifactTrust,
+                      worktreePath
+                    }
+                  }
+                );
+              } else if (isDirty) {
+                const add = await measurePostProviderPhase(
+                  postProviderPhaseDurationsMs,
+                  "repairPromotionStage",
+                  verbose,
+                  async () => execa3("git", ["add", "-A"], {
+                    cwd: worktreePath,
+                    stdio: "pipe",
+                    reject: false
+                  })
+                );
+                if ((add.exitCode ?? 0) !== 0 && verbose) {
+                  console.warn(
+                    chalk.yellow(
+                      `Failed to stage repairs (exit ${add.exitCode ?? "unknown"}); preserving worktree for manual commit.`
+                    )
+                  );
+                }
+                const isFullyClean = verificationLoop.passed;
+                const commitMsg = isFullyClean ? `fix: repair-loop (${iterCount} iterations) - all gates pass` : `fix: repair-loop (${iterCount} iterations) - no new regressions vs baseline`;
+                const commit = await measurePostProviderPhase(
+                  postProviderPhaseDurationsMs,
+                  "repairPromotionCommit",
+                  verbose,
+                  async () => execa3("git", ["commit", "--no-verify", "-m", commitMsg], {
+                    cwd: worktreePath,
+                    stdio: "pipe",
+                    reject: false
+                  })
+                );
+                commitSucceeded = (commit.exitCode ?? 0) === 0;
+                if ((commit.exitCode ?? 0) !== 0 && verbose) {
+                  const output = String(commit.stdout ?? commit.stderr ?? "").trim();
+                  console.warn(
+                    chalk.yellow(
+                      `Failed to commit repairs (exit ${commit.exitCode ?? "unknown"}); preserving worktree for manual commit.${output ? `
+${output}` : ""}`
+                    )
+                  );
+                }
+              }
+              result.repairOutcome = {
+                attempted: true,
+                passed: verificationLoop.passed,
+                passedBaseline: verificationLoop.passedBaseline,
+                iterations: verificationLoop.iterations.length,
+                stopReason: verificationLoop.stopReason,
+                filesChanged: repairedSummary.filesChanged,
+                committed: commitSucceeded,
+                repairTrigger: buildRepairTriggerEvidence(repairOutcome),
+                ...repairScopeAnalysis.preRepairDiff ? { preRepairDiff: repairScopeAnalysis.preRepairDiff } : {},
+                ...repairScopeAnalysis.finalDiff ? { finalDiff: repairScopeAnalysis.finalDiff } : {},
+                ...repairScopeAnalysis.repairDelta ? { repairDelta: repairScopeAnalysis.repairDelta } : {},
+                classification: repairScopeAnalysis.classification,
+                judgeVerdictApplicability: repairScopeAnalysis.judgeVerdictApplicability,
+                finalArtifactTrust: repairPolicy.finalArtifactTrust,
+                policy: repairPolicy
+              };
+              if (repairedSummary.filesChanged > 0) {
+                result.gitMetrics = {
+                  filesChanged: repairedSummary.filesChanged,
+                  linesAdded: repairedSummary.linesAdded,
+                  linesDeleted: repairedSummary.linesRemoved,
+                  source: repairedSummary.source === "fallback" ? "unknown" : "worktree"
+                };
+              }
+              if (repairedSummary.filesChanged > 0) {
+                result.emptyChanges = false;
+              }
+              if (verbose) {
+                const baselineStatus = verificationLoop.passed ? "all gates pass" : "no new regressions";
+                console.log(
+                  chalk.green(
+                    commitSucceeded ? `Verification repairs committed (${iterCount} iterations, ${repairedSummary.filesChanged} files, ${baselineStatus})` : `Verification repairs preserved (${iterCount} iterations, ${repairedSummary.filesChanged} files, ${baselineStatus})`
+                  )
+                );
+              }
+            } catch (commitError) {
+              if (verbose) {
+                const msg = commitError instanceof Error ? commitError.message : String(commitError);
+                console.warn(chalk.yellow(`Failed to commit repairs: ${msg}`));
+              }
+            }
+          }
+        }
+      }
+      measurePostProviderPhaseSync(
+        postProviderPhaseDurationsMs,
+        "verifiedTouchedTestGuard",
+        verbose,
+        () => applyVerifiedTouchedTestFailureGuard(result, repairOutcomeForGuards)
+      );
+      if (result.gitMetrics && result.gitMetrics.filesChanged > 0) {
+        result.filesChanged = result.gitMetrics.filesChanged;
+        result.linesAdded = result.gitMetrics.linesAdded;
+        result.linesRemoved = result.gitMetrics.linesDeleted;
+      }
+      const workspaceEditsApplied = result.workspaceEditsApplied ?? 0;
+      if (result.gitMetrics && result.gitMetrics.filesChanged > 0 && (result.completeness ?? 0) === 0 && workspaceEditsApplied === 0) {
+        console.warn(
+          chalk.yellow(
+            "[Telemetry] Git shows changes but completeness is 0 and no workspace edits were applied."
+          ),
+          {
+            filesChanged: result.gitMetrics.filesChanged,
+            linesAdded: result.gitMetrics.linesAdded,
+            linesDeleted: result.gitMetrics.linesDeleted,
+            provider: variant.provider,
+            strategy: variant.strategy,
+            executionIntent: variant.executionIntent
+          }
+        );
+      }
+      if (!result.verificationLoop && validationArtifactSatisfied !== true && !isAnalysisIntent && result.success === true && hasMaterializedDeliverable && typeof result.retainedWorktreePath === "string" && result.retainedWorktreePath.trim().length > 0 && typeof result.baselineRef === "string" && result.baselineRef.trim().length > 0) {
+        const worktreePath = result.retainedWorktreePath.trim();
+        const baselineRef = result.baselineRef.trim();
+        const repoRoot2 = process.cwd();
+        const cacheDir = path.join(repoRoot2, ".poetic", "cache", "verification-baseline");
+        const verificationChangedFiles = await taskScopedChangedFiles(worktreePath, baselineRef);
+        const baselineForVerification = await measurePostProviderPhase(
+          postProviderPhaseDurationsMs,
+          "verificationBaselineCapture",
+          verbose,
+          async () => getOrCaptureVerificationBaseline({
+            repoRoot: repoRoot2,
+            baselineRef,
+            cacheDir,
+            captureOptions: { gateTimeoutMs: 6e4, changedFiles: verificationChangedFiles }
+          }).catch(() => null)
+        );
+        const verificationOutcome = await measurePostProviderPhase(
+          postProviderPhaseDurationsMs,
+          "deterministicVerification",
+          verbose,
+          async () => runDeterministicVerificationOnce({
+            worktreePath,
+            baselineRef,
+            timeoutMs: Math.max(5e3, Math.floor(repairLoopConfig.iterationTimeoutMs)),
+            baseline: baselineForVerification?.metadata?.captureSucceeded ? baselineForVerification : void 0,
+            checkTestGate: true,
+            // Same scope as the baseline capture above (symmetry invariant).
+            changedFiles: verificationChangedFiles
+          })
+        );
+        result.verification = verificationOutcome.verification;
+        result.verificationLoop = verificationOutcome.verificationLoop;
+      }
+      try {
+        await measurePostProviderPhase(
+          postProviderPhaseDurationsMs,
+          "baselineComparison",
+          verbose,
+          async () => attachBaselineComparisonIfAvailable(result)
+        );
+      } catch {
+      }
+      try {
+        await measurePostProviderPhase(
+          postProviderPhaseDurationsMs,
+          "registryDowngrade",
+          verbose,
+          async () => applyRegistryDowngradeIfApplicable(result)
+        );
+      } catch {
+      }
+      measurePostProviderPhaseSync(
+        postProviderPhaseDurationsMs,
+        "outcomeDerivation",
+        verbose,
+        () => {
+          result.outcome = deriveVariantOutcome(result);
+          result.verificationDisposition = getVerificationResult(result);
+        }
+      );
+      if (specSignal) {
+        result.inputSpecWarning = {
+          completenessScore: specSignal.completenessScore,
+          guidanceTier: specSignal.guidanceTier,
+          missingFields: [...specSignal.missingFields],
+          hasFillPlaceholders: specSignal.hasFillPlaceholders
+        };
+      }
+      if (verbose) {
+        console.log(
+          chalk.green(`Execution completed in ${duration.toFixed(2)}s (success: ${result.success})`)
+        );
+        console.log(chalk.gray(`   ${formatVerboseWorkerCompletionMetric(variant, result)}`));
+        if (specSignal) {
+          const missingNames = specSignal.missingFields.map(
+            (field) => FIELD_DISPLAY_NAMES[field] ?? field
+          );
+          console.log(
+            chalk.yellow(
+              `   Note: execution started from an incomplete spec (${Math.round(specSignal.completenessScore * 100)}% complete; missing: ${missingNames.join(", ")})`
+            )
+          );
+        }
+      }
+      if (telemetryEnabled && telemetry) {
+        try {
+          const processReliability = computeProcessReliabilityMetrics({
+            success: result.success,
+            result: result.result
+          });
+          let terminationReason;
+          if (result.terminationReason) {
+            terminationReason = result.terminationReason;
+          } else if (result.success) {
+            terminationReason = "completed";
+          } else if (result.timedOut) {
+            terminationReason = "timeout";
+          } else {
+            terminationReason = "failed_error";
+          }
+          telemetry.logVariantEvent(taskId, formatVariantIdentifier(variant), "completed", {
+            success: result.success,
+            completeness: result.completeness,
+            duration,
+            provider: variant.provider,
+            model: variant.model,
+            executionMode: variant.executionMode,
+            strategy: variant.strategy,
+            runMode,
+            executionIntent: variant.executionIntent,
+            behavioralMetrics: { processReliability },
+            terminationReason
+          });
+          const verdict = result.success ? "success" : "failure";
+          telemetry.logVariantEvent(taskId, formatVariantIdentifier(variant), "evaluated", {
+            verdict,
+            completeness: result.completeness,
+            codeDelivered: result.success && result.completeness > 0,
+            provider: variant.provider,
+            model: variant.model,
+            executionMode: variant.executionMode,
+            strategy: variant.strategy,
+            runMode,
+            executionIntent: variant.executionIntent
+          });
+          await measurePostProviderPhase(
+            postProviderPhaseDurationsMs,
+            "telemetryArtifactWrite",
+            verbose,
+            async () => {
+              const artifactResult = await telemetry.logVariantResultWithArtifact(
+                taskId,
+                formatVariantIdentifier(variant),
+                result,
+                {
+                  provider: variant.provider,
+                  model: variant.model,
+                  executionMode: variant.executionMode,
+                  runMode,
+                  executionIntent: variant.executionIntent
+                }
+              );
+              if (artifactResult?.success && artifactResult.manifestPath) {
+                result.artifactManifest = artifactResult.manifestPath;
+              }
+            }
+          );
+        } catch (_err) {
+          await warnOnce(
+            "Telemetry logging failed mid-run; disabling telemetry for this worker.",
+            telemetryWarning
+          );
+          telemetryEnabled = false;
+        }
+      }
+    } catch (error) {
+      const duration = Number(process.hrtime.bigint() - startTime) / 1e9;
+      const errorObj = error instanceof Error ? error : new Error(String(error));
+      result = {
+        variant: formatVariantIdentifier(variant),
+        provider: variant.provider,
+        model: variant.model,
+        strategy: variant.strategy,
+        executionMode: variant.executionMode,
+        success: false,
+        error: errorObj,
+        duration,
+        completeness: 0,
+        executionIntent: variant.executionIntent,
+        isBasicCompetition: variant.isBasicCompetition,
+        // Record requested prompt mode even on failure
+        promptModeRequested: variant.promptMode,
+        ...specSignal ? {
+          inputSpecWarning: {
+            completenessScore: specSignal.completenessScore,
+            guidanceTier: specSignal.guidanceTier,
+            missingFields: [...specSignal.missingFields],
+            hasFillPlaceholders: specSignal.hasFillPlaceholders
+          }
+        } : {}
+      };
+      const errorTerminationReason = result.terminationReason || (result.timedOut ? "timeout" : "failed_crash");
+      result.terminationReason = errorTerminationReason;
+      result.outcome = deriveVariantOutcome(result);
+      if (telemetryEnabled && telemetry) {
+        try {
+          const processReliability = computeProcessReliabilityMetrics({
+            success: false,
+            result: result.result
+          });
+          telemetry.logVariantEvent(taskId, formatVariantIdentifier(variant), "completed", {
+            success: false,
+            completeness: 0,
+            duration,
+            provider: variant.provider,
+            model: variant.model,
+            executionMode: variant.executionMode,
+            strategy: variant.strategy,
+            runMode,
+            executionIntent: variant.executionIntent,
+            behavioralMetrics: { processReliability },
+            terminationReason: errorTerminationReason
+          });
+          telemetry.logVariantEvent(taskId, formatVariantIdentifier(variant), "evaluated", {
+            verdict: "failure",
+            completeness: 0,
+            codeDelivered: false,
+            provider: variant.provider,
+            model: variant.model,
+            executionMode: variant.executionMode,
+            strategy: variant.strategy,
+            runMode,
+            executionIntent: variant.executionIntent
+          });
+          const artifactResult = await telemetry.logVariantResultWithArtifact(
+            taskId,
+            formatVariantIdentifier(variant),
+            result,
+            {
+              provider: variant.provider,
+              model: variant.model,
+              executionMode: variant.executionMode,
+              runMode,
+              executionIntent: variant.executionIntent
+            }
+          );
+          if (artifactResult?.success && artifactResult.manifestPath) {
+            result.artifactManifest = artifactResult.manifestPath;
+          }
+        } catch (_err) {
+          await warnOnce(
+            "Telemetry logging failed mid-run; disabling telemetry for this worker.",
+            telemetryWarning
+          );
+          telemetryEnabled = false;
+        }
+      }
+      if (verbose) {
+        console.error(chalk.red(`Execution failed: ${errorObj.message}`));
+        if (specSignal) {
+          const missingNames = specSignal.missingFields.map(
+            (field) => FIELD_DISPLAY_NAMES[field] ?? field
+          );
+          console.error(
+            chalk.yellow(
+              `   Note: execution started from an incomplete spec (${Math.round(specSignal.completenessScore * 100)}% complete; missing: ${missingNames.join(", ")})`
+            )
+          );
+        }
+      }
+    }
+    providerOutputForwarder.close();
+    if (!result.postProviderPhaseDurationsMs) {
+      result.postProviderPhaseDurationsMs = {};
+    }
+    const finalPostProviderPhaseDurationsMs = result.postProviderPhaseDurationsMs;
+    if (result.success === true && shouldDowngradeSuccessfulResultForShutdown({
+      shutdownRequested,
+      shutdownRequestedAtMs,
+      executionResultSettledAtMs
+    })) {
+      const signal = shutdownSignal ?? "SIGTERM";
+      result.success = false;
+      result.timedOut = signal === "SIGTERM";
+      result.terminationReason = signal === "SIGINT" ? "canceled_user" : "timeout";
+      result.error = new Error(
+        signal === "SIGINT" ? "Worker interrupted before final result could be trusted" : "Worker received SIGTERM before final result could be trusted"
+      );
+    }
+    measurePostProviderPhaseSync(
+      finalPostProviderPhaseDurationsMs,
+      "finalOutcomeDerivation",
+      verbose,
+      () => {
+        result.outcome = deriveVariantOutcome(result);
+      }
+    );
+    const worktreePathForCleanup = cleanupWorktreeAfterRun && result.success === true && typeof result.retainedWorktreePath === "string" ? result.retainedWorktreePath.trim() : void 0;
+    if (worktreePathForCleanup) {
+      result.retainedWorktreePath = void 0;
+    }
+    measurePostProviderPhaseSync(
+      finalPostProviderPhaseDurationsMs,
+      "resultFinalize",
+      verbose,
+      () => {
+        if (result.result) {
+          if (isNativeResearchEnabledFor(variant.provider)) {
+            const rawTranscript = `${result.result.rawStdout ?? ""}
+${result.result.rawStderr ?? ""}`;
+            if (rawTranscript.trim().length > 0) {
+              const scan = scanWebToolEvents(rawTranscript);
+              if (scan.corroboratedUrls.size > 0) {
+                result.result.researchCorroboratedUrls = Array.from(scan.corroboratedUrls);
+              }
+              if (scan.observedWebToolEvent) {
+                result.result.researchObservedWebToolEvent = true;
+              }
+            }
+          }
+          result.result.rawStdout = void 0;
+          result.result.rawStderr = void 0;
+          if (result.result.stdout && Buffer.byteLength(result.result.stdout, "utf8") > 2e5) {
+            result.result.stdout = truncateToByteLimit(result.result.stdout, 2e5);
+          }
+          if (result.result.stderr && Buffer.byteLength(result.result.stderr, "utf8") > 2e5) {
+            result.result.stderr = truncateToByteLimit(result.result.stderr, 2e5);
+          }
+        }
+      }
+    );
+    sanitizeVariantResult(result);
+    try {
+      await measurePostProviderPhase(
+        finalPostProviderPhaseDurationsMs,
+        "resultWrite",
+        verbose,
+        async () => writeResultFileAtomically(resultFile, result)
+      );
+      emitWorkerLifecycleMarker(RESULT_WRITTEN_MARKER_PREFIX, elapsedMsSince(startTime));
+      emitWorkerLifecycleMarker(
+        POST_PROVIDER_PHASES_MARKER_PREFIX,
+        finalPostProviderPhaseDurationsMs
+      );
+      if (verbose) {
+        console.log(chalk.green(`Result written to ${resultFile}`));
+      }
+      if (telemetryEnabled && telemetry) {
+        try {
+          TelemetryLogger.disposeShared();
+        } catch (_err) {
+        }
+      }
+      if (worktreePathForCleanup && worktreePathForCleanup.length > 0) {
+        await measurePostProviderPhase(
+          finalPostProviderPhaseDurationsMs,
+          "cleanup",
+          verbose,
+          async () => tryCleanupRetainedWorktree(worktreePathForCleanup, verbose)
+        );
+      }
+      applyWorkerEnvOverrides({
+        POETIC_RETAIN_BASIC_WORKTREE: prevRetainBasicWorktree
+      });
+      emitWorkerLifecycleMarker(CLEANUP_START_MARKER_PREFIX, elapsedMsSince(startTime));
+      await measurePostProviderPhase(
+        finalPostProviderPhaseDurationsMs,
+        "cleanup",
+        verbose,
+        async () => signalCoordinator.runCleanupHandlers("variant-worker exit", {
+          timeoutMs: SIGNAL_CLEANUP_TIMEOUT_MS
+        })
+      );
+      emitWorkerLifecycleMarker(CLEANUP_COMPLETE_MARKER_PREFIX, elapsedMsSince(startTime));
+      emitWorkerLifecycleMarker(
+        POST_PROVIDER_PHASES_MARKER_PREFIX,
+        finalPostProviderPhaseDurationsMs
+      );
+      emitWorkerLifecycleMarker(ACTIVE_HANDLES_MARKER_PREFIX, activeHandleSummary());
+      if (preserveWorktreesForDebug) {
+        applyWorkerEnvOverrides({
+          POETIC_PRESERVE_WORKTREES: prevPreserveWorktrees
+        });
+      }
+      return;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(chalk.red(`Failed to write result: ${message}`));
+      if (telemetryEnabled && telemetry) {
+        try {
+          TelemetryLogger.disposeShared();
+        } catch (_err) {
+        }
+      }
+      applyWorkerEnvOverrides({
+        POETIC_RETAIN_BASIC_WORKTREE: prevRetainBasicWorktree
+      });
+      await signalCoordinator.runCleanupHandlers("variant-worker fatal-exit", {
+        timeoutMs: SIGNAL_CLEANUP_TIMEOUT_MS
+      });
+      if (preserveWorktreesForDebug) {
+        applyWorkerEnvOverrides({
+          POETIC_PRESERVE_WORKTREES: prevPreserveWorktrees
+        });
+      }
+      throw new ExitCodeError(1, message);
+    }
+  } finally {
+    uninstallPostProviderSignalHandlers();
+    signalCoordinator.unregister(signalHandlerName);
+    signalCoordinator.unregister(processLifecycleSignalHandlerName);
+    setProcessLifecycleManager(void 0);
+  }
+}
+var workerEntrypoint = fileURLToPath(import.meta.url);
+var invokedScript = process.argv[1] ? path.resolve(process.argv[1]) : null;
+var isDirectInvocation = invokedScript !== null && path.resolve(workerEntrypoint) === invokedScript;
+async function runVariantWorkerEntrypoint(entryOptions = {}) {
+  if (!entryOptions.runtimeAlreadyChecked) {
+    assertPoeticRuntimeReady({ command: "variant-worker" });
+  }
+  try {
+    await main();
+    return 0;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(chalk.red(`Unhandled error: ${message}`));
+    try {
+      const argv = process.argv;
+      const flagIdx = argv.indexOf("--result-file");
+      const resultFile = flagIdx !== -1 && flagIdx + 1 < argv.length ? argv[flagIdx + 1] : void 0;
+      if (resultFile) {
+        const payload = {
+          success: false,
+          error: { message, stage: "bootstrap" },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await writeResultFileAtomically(resultFile, payload);
+      }
+    } catch {
+    }
+    return error instanceof ExitCodeError ? error.exitCode : 1;
+  }
+}
+if (process.env.VITEST !== "1" && isDirectInvocation) {
+  runVariantWorkerEntrypoint().then((exitCode) => {
+    if (exitCode === 0) {
+      process.exitCode = 0;
+    } else {
+      process.exit(exitCode);
+    }
+  }).catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(1);
+  });
+}
+export {
+  __testOnlyWriteResultFileAtomically,
+  applyVerifiedTouchedTestFailureGuard,
+  attachBaselineComparisonIfAvailable,
+  buildRepairTriggerEvidence,
+  createProviderOutputForwarder,
+  decideRepairAdmission,
+  executeWorker,
+  extractOriginalPrompt,
+  formatVerboseWorkerCompletionMetric,
+  hasVerifiedTouchedTestFailure2 as hasVerifiedTouchedTestFailure,
+  isValidationArtifactOnlyPrompt,
+  resolveRepairPromotionPolicy,
+  runVariantWorkerEntrypoint,
+  serializeErrorForJson,
+  shouldDowngradeSuccessfulResultForShutdown,
+  shouldSkipRepairLoopForPassingGates,
+  shouldTrustVerificationLoopBaseline,
+  tryCleanupRetainedWorktree
+};
+//# sourceMappingURL=variant-worker-KUWKBLAH.js.map