@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-SKTFRFQ7.js

@@ -0,0 +1,1775 @@
+import {
+  isYesAnswer
+} from "./chunk-O5X6BKAO.js";
+import {
+  gatesAlsoFailingOnBase
+} from "./chunk-R2CKS6WT.js";
+import {
+  readVariantVerification
+} from "./chunk-3OPP2OZB.js";
+import {
+  detectRemoteConfiguration,
+  prSkipNoRemoteNotice
+} from "./chunk-EPRMH6HO.js";
+import {
+  execGitSyncChecked
+} from "./chunk-XHOI4V62.js";
+import {
+  assertSafePathComponent
+} from "./chunk-S2VQCZO4.js";
+import {
+  aggregateResolverOutcomes,
+  classifyResolverCommand
+} from "./chunk-6TBEX4R4.js";
+import {
+  FileLockCompromisedError,
+  acquireFencedFileLock,
+  ensureLockTargetFile
+} from "./chunk-QYQOVOLR.js";
+import {
+  prepareUntrackedIntentIndex
+} from "./chunk-QFLBRWCJ.js";
+import {
+  filterDeliveryPatchByExcludedPaths
+} from "./chunk-AEQWV746.js";
+import {
+  parseDiffGitHeaderPaths,
+  parseUnifiedDiffPathLine
+} from "./chunk-5FKHIKTS.js";
+import {
+  runVerificationCommand
+} from "./chunk-S2E632FQ.js";
+import {
+  CURRENT_BRANCH_REV_PARSE_ARGS,
+  assertBranchAllowsCodeApply,
+  parseCurrentBranchRef
+} from "./chunk-XGU6PBO5.js";
+import {
+  captureCurrentWorkspaceTreeIdentity
+} from "./chunk-YO5BAJ55.js";
+import {
+  parsePorcelainEntriesZ
+} from "./chunk-EVE3OD2W.js";
+import {
+  mkBuildTempDir
+} from "./chunk-D6WTZMZB.js";
+import {
+  readTrackedToolOutputRootsSync,
+  shouldExcludeStatusPath
+} from "./chunk-5EQN56OZ.js";
+import {
+  resolveVerificationChannelScope
+} from "./chunk-AHU3FKPA.js";
+import {
+  deriveVerificationDisposition,
+  formatUnverifiedDeliveryLabel
+} from "./chunk-TUQMMFEQ.js";
+import {
+  isGeneratedLockfilePath
+} from "./chunk-D4VJFCGZ.js";
+import {
+  safeRmDir
+} from "./chunk-ALDTFNZ3.js";
+import {
+  isUnderNestedToolOutputDir
+} from "./chunk-QOIASNEJ.js";
+import {
+  decodeGitQuotedPathBody
+} from "./chunk-J2ICMYDA.js";
+import {
+  toVariantSlug
+} from "./chunk-2VLJUXJU.js";
+import {
+  LabPathResolver
+} from "./chunk-C3KCMAJP.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import {
+  redactTelemetryValue
+} from "./chunk-WV3KQDPE.js";
+import {
+  assertContainedPath,
+  isSymlink
+} from "./chunk-RCP2Y6DQ.js";
+import {
+  DEFAULT_TIMEOUT_MS
+} from "./chunk-I56TH7VM.js";
+import {
+  readBuildPackageVersion
+} from "./chunk-RJ6RSNT6.js";
+import {
+  BUILD_ALLOW_OFF_SCOPE_REPAIR,
+  getExecutionContext,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/compete/apply-completion-mode.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync2, mkdirSync, writeFileSync } from "fs";
+import { join as join5 } from "path";
+
+// src/telemetry/artifact-storage.ts
+import { createHash } from "crypto";
+import * as fsSync from "fs";
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import { gunzipSync, gzipSync } from "zlib";
+
+// src/core/utils/build-artifact-dir.ts
+import * as fs from "fs";
+import * as path from "path";
+function realpathExisting(root) {
+  try {
+    return fs.realpathSync.native(path.resolve(root));
+  } catch {
+    throw new Error(`Repository root is unresolvable: ${root}`);
+  }
+}
+function rebaseOntoCanonicalRoot(lexicalRoot, canonicalRoot, candidate) {
+  const relative3 = path.relative(path.resolve(lexicalRoot), path.resolve(candidate));
+  if (relative3 === "") {
+    return canonicalRoot;
+  }
+  if (!relative3.startsWith("..") && !path.isAbsolute(relative3)) {
+    return path.join(canonicalRoot, relative3);
+  }
+  return path.resolve(candidate);
+}
+function assertBuildBucketWritePath(repoRoot, bucketRoot, targetDir, label) {
+  const canonicalRepo = realpathExisting(repoRoot);
+  const resolvedBucket = path.resolve(bucketRoot);
+  if (isSymlink(resolvedBucket)) {
+    throw new Error(`${label} refuses a symlinked bucket root: ${resolvedBucket}`);
+  }
+  const canonicalTarget = assertContainedPath(
+    canonicalRepo,
+    rebaseOntoCanonicalRoot(repoRoot, canonicalRepo, targetDir),
+    label
+  );
+  const canonicalBucket = rebaseOntoCanonicalRoot(repoRoot, canonicalRepo, bucketRoot);
+  assertContainedPath(canonicalBucket, canonicalTarget, `${label} bucket`);
+  return canonicalTarget;
+}
+
+// src/telemetry/artifact-storage.ts
+var RAW_SIZE_THRESHOLD_BYTES = 1024 * 1024;
+var MAX_DECOMPRESSED_DIFF_BYTES = RAW_SIZE_THRESHOLD_BYTES;
+var COMPRESSED_SIZE_THRESHOLD_BYTES = 500 * 1024;
+var MANIFEST_VERSION = 1;
+async function resolveContainedExistingFile(baseDir, filename) {
+  const candidatePath = path2.resolve(baseDir, filename);
+  const [realBaseDir, realCandidatePath] = await Promise.all([
+    fs2.realpath(baseDir),
+    fs2.realpath(candidatePath)
+  ]);
+  const relative3 = path2.relative(realBaseDir, realCandidatePath);
+  if (relative3 === "" || relative3.startsWith("..") || path2.isAbsolute(relative3)) {
+    return null;
+  }
+  return realCandidatePath;
+}
+function canonicalizeBuildRoot(buildRoot) {
+  try {
+    return fsSync.realpathSync.native(path2.resolve(buildRoot));
+  } catch {
+    return path2.resolve(buildRoot);
+  }
+}
+function getArtifactDir(buildRoot, taskId, variantSlug) {
+  const root = canonicalizeBuildRoot(buildRoot);
+  const safeTaskId = assertSafePathComponent(taskId, "taskId");
+  const safeVariantSlug = assertSafePathComponent(variantSlug, "variantSlug");
+  const buildDir = path2.join(root, ".build-project");
+  const labResolver = LabPathResolver.getInstance();
+  const baseDir = labResolver.getArtifactDir(buildDir);
+  const artifactDir = path2.join(baseDir, safeTaskId, safeVariantSlug);
+  return assertBuildBucketWritePath(root, baseDir, artifactDir, "Artifact directory");
+}
+async function getGitVersion() {
+  try {
+    const { execSync } = await import("child_process");
+    const result = execSync("git --version", { encoding: "utf-8", timeout: 5e3 });
+    return result.trim();
+  } catch {
+    return void 0;
+  }
+}
+async function getBuildVersion() {
+  return readBuildPackageVersion() ?? "unknown";
+}
+async function atomicWrite(filePath, data) {
+  const tmpPath = `${filePath}.tmp.${process.pid}`;
+  try {
+    await fs2.writeFile(tmpPath, data);
+    await fs2.rename(tmpPath, filePath);
+  } catch (error) {
+    try {
+      await fs2.unlink(tmpPath);
+    } catch {
+    }
+    throw error;
+  }
+}
+function sha256(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+function containsBinaryContent(diff) {
+  return diff.includes("Binary files") || diff.includes("GIT binary patch") || // Check for high ratio of non-printable characters
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: intentional binary detection
+  /[\x00-\x08\x0E-\x1F]/.test(diff.slice(0, 1e4));
+}
+function evidenceFilenameForDiffSource(diffSource) {
+  if (diffSource === "worktreeDiff") return "diff.patch.gz";
+  if (diffSource === "output") return "analysis.txt.gz";
+  return "stdout.txt.gz";
+}
+async function persistVariantArtifact(options) {
+  const {
+    taskId,
+    variantSpec,
+    provider,
+    variant,
+    filteredDiff,
+    diffSource,
+    baseCommitSha,
+    baseTreeSha,
+    judgeScore,
+    completeness,
+    buildRoot: buildRootOption = process.cwd()
+  } = options;
+  const buildRoot = canonicalizeBuildRoot(buildRootOption);
+  const redactedValue = redactTelemetryValue(filteredDiff);
+  const redactedDiff = typeof redactedValue === "string" ? redactedValue : String(redactedValue);
+  try {
+    const variantSlug = toVariantSlug(variantSpec);
+    const artifactDir = getArtifactDir(buildRoot, taskId, variantSlug);
+    await fs2.mkdir(artifactDir, { recursive: true });
+    const [gitVersion, buildVersion] = await Promise.all([getGitVersion(), getBuildVersion()]);
+    const manifest = {
+      manifestVersion: MANIFEST_VERSION,
+      buildVersion,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      taskId,
+      variantSpec,
+      variantSlug,
+      provider,
+      variant,
+      diff: {
+        status: "skipped",
+        rawByteCount: Buffer.byteLength(redactedDiff, "utf-8"),
+        replayable: options.replayable !== false && redactedDiff === filteredDiff
+      },
+      reconstruction: {
+        diffSource,
+        filteringApplied: true,
+        gitVersion,
+        baseCommitSha,
+        baseTreeSha
+      }
+    };
+    if (judgeScore !== void 0 || completeness !== void 0) {
+      manifest.scores = {
+        judgeScore,
+        completeness
+      };
+    }
+    const manifestPath = path2.join(artifactDir, "manifest.json");
+    const artifactFilename = evidenceFilenameForDiffSource(diffSource);
+    const diffPath = path2.join(artifactDir, artifactFilename);
+    if (!redactedDiff || redactedDiff.trim().length === 0) {
+      manifest.diff.status = "skipped";
+      manifest.diff.skipReason = "empty";
+      await atomicWrite(manifestPath, JSON.stringify(manifest, null, 2));
+      return {
+        success: true,
+        manifestPath: path2.relative(buildRoot, manifestPath),
+        manifest
+      };
+    }
+    if (containsBinaryContent(redactedDiff)) {
+      manifest.diff.status = "skipped";
+      manifest.diff.skipReason = "binary_content";
+      await atomicWrite(manifestPath, JSON.stringify(manifest, null, 2));
+      return {
+        success: true,
+        manifestPath: path2.relative(buildRoot, manifestPath),
+        manifest
+      };
+    }
+    if (manifest.diff.rawByteCount > RAW_SIZE_THRESHOLD_BYTES) {
+      manifest.diff.status = "skipped";
+      manifest.diff.skipReason = "too_large";
+      manifest.diff.sizeThreshold = COMPRESSED_SIZE_THRESHOLD_BYTES;
+      await atomicWrite(manifestPath, JSON.stringify(manifest, null, 2));
+      return {
+        success: true,
+        manifestPath: path2.relative(buildRoot, manifestPath),
+        manifest
+      };
+    }
+    const compressed = gzipSync(Buffer.from(redactedDiff, "utf-8"));
+    const compressedSize = compressed.length;
+    if (compressedSize > COMPRESSED_SIZE_THRESHOLD_BYTES) {
+      manifest.diff.status = "skipped";
+      manifest.diff.skipReason = "too_large";
+      manifest.diff.compressedByteCount = compressedSize;
+      manifest.diff.sizeThreshold = COMPRESSED_SIZE_THRESHOLD_BYTES;
+      await atomicWrite(manifestPath, JSON.stringify(manifest, null, 2));
+      return {
+        success: true,
+        manifestPath: path2.relative(buildRoot, manifestPath),
+        manifest
+      };
+    }
+    await atomicWrite(diffPath, compressed);
+    const diffHash = sha256(compressed);
+    manifest.diff.status = "persisted";
+    manifest.diff.filename = artifactFilename;
+    manifest.diff.sha256 = diffHash;
+    manifest.diff.compressedByteCount = compressedSize;
+    await atomicWrite(manifestPath, JSON.stringify(manifest, null, 2));
+    return {
+      success: true,
+      manifestPath: path2.relative(buildRoot, manifestPath),
+      diffPath: path2.relative(buildRoot, diffPath),
+      manifest
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function readArtifactManifest(buildRoot, taskId, variantSlug) {
+  try {
+    const artifactDir = getArtifactDir(buildRoot, taskId, variantSlug);
+    const manifestPath = path2.join(artifactDir, "manifest.json");
+    const content = await fs2.readFile(manifestPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function readArtifactDiff(buildRoot, taskId, variantSlug, requireReplayable = false) {
+  try {
+    const artifactDir = getArtifactDir(buildRoot, taskId, variantSlug);
+    const manifest = await readArtifactManifest(buildRoot, taskId, variantSlug);
+    if (requireReplayable && manifest?.diff.replayable !== true) return null;
+    const diffFilename = manifest?.diff.filename ?? "diff.patch.gz";
+    const diffPath = await resolveContainedExistingFile(artifactDir, diffFilename);
+    if (!diffPath) {
+      return null;
+    }
+    const compressed = await fs2.readFile(diffPath);
+    return gunzipSync(compressed, { maxOutputLength: MAX_DECOMPRESSED_DIFF_BYTES }).toString(
+      "utf-8"
+    );
+  } catch {
+    return null;
+  }
+}
+async function readArtifactDiffFromManifestPath(manifestPath, buildRoot = process.cwd(), requireReplayable = false) {
+  const manifest = await readArtifactManifestFromPath(manifestPath, buildRoot);
+  if (!manifest) {
+    return null;
+  }
+  try {
+    if (manifest.diff.status !== "persisted" || requireReplayable && manifest.diff.replayable !== true) {
+      return null;
+    }
+    const absoluteManifestPath = path2.isAbsolute(manifestPath) ? manifestPath : path2.join(buildRoot, manifestPath);
+    const diffFilename = manifest.diff.filename ?? "diff.patch.gz";
+    const manifestDir = path2.dirname(absoluteManifestPath);
+    const diffPath = await resolveContainedExistingFile(manifestDir, diffFilename);
+    if (!diffPath) {
+      return null;
+    }
+    const compressed = await fs2.readFile(diffPath);
+    return gunzipSync(compressed, { maxOutputLength: MAX_DECOMPRESSED_DIFF_BYTES }).toString(
+      "utf-8"
+    );
+  } catch {
+    return null;
+  }
+}
+async function readArtifactManifestFromPath(manifestPath, buildRoot = process.cwd()) {
+  if (!manifestPath || manifestPath.trim().length === 0) {
+    return null;
+  }
+  try {
+    const absoluteManifestPath = path2.isAbsolute(manifestPath) ? manifestPath : path2.join(buildRoot, manifestPath);
+    const manifestContent = await fs2.readFile(absoluteManifestPath, "utf-8");
+    return JSON.parse(manifestContent);
+  } catch {
+    return null;
+  }
+}
+async function listTaskArtifacts(buildRoot, taskId) {
+  try {
+    const buildDir = path2.join(canonicalizeBuildRoot(buildRoot), ".build-project");
+    const labResolver = LabPathResolver.getInstance();
+    const taskDir = path2.join(
+      labResolver.getArtifactDir(buildDir),
+      assertSafePathComponent(taskId, "taskId")
+    );
+    const entries = await fs2.readdir(taskDir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+function createArtifactPointer(result) {
+  if (!result.success || !result.manifestPath) {
+    return void 0;
+  }
+  return { artifactManifest: result.manifestPath };
+}
+
+// src/core/git/checkout-mutation-lock.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+var CHECKOUT_MUTATION_LOCK_STALE_MS = 12e4;
+var CHECKOUT_MUTATION_LOCK_RETRIES = 120;
+var CHECKOUT_MUTATION_LOCK_MIN_TIMEOUT_MS = 250;
+var CHECKOUT_MUTATION_LOCK_MAX_TIMEOUT_MS = 2e3;
+var CHECKOUT_MUTATION_LOCK_BACKOFF_FACTOR = 1.5;
+function getCheckoutMutationLockTarget(projectRoot) {
+  return path3.join(projectRoot, ".build-project", "merge-apply", ".apply.lock");
+}
+async function resolveCheckoutMutationLockRoot(projectRoot) {
+  try {
+    return await fs3.realpath(projectRoot);
+  } catch {
+    return projectRoot;
+  }
+}
+async function acquireCheckoutMutationLock(projectRoot) {
+  const canonicalRoot = await resolveCheckoutMutationLockRoot(projectRoot);
+  const lockTarget = getCheckoutMutationLockTarget(canonicalRoot);
+  try {
+    await fs3.mkdir(path3.dirname(lockTarget), { recursive: true });
+    await ensureLockTargetFile(lockTarget);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to prepare checkout mutation lock at ${lockTarget}: ${msg}`);
+  }
+  return acquireFencedFileLock(lockTarget, {
+    stale: CHECKOUT_MUTATION_LOCK_STALE_MS,
+    realpath: false,
+    retries: {
+      retries: CHECKOUT_MUTATION_LOCK_RETRIES,
+      minTimeout: CHECKOUT_MUTATION_LOCK_MIN_TIMEOUT_MS,
+      maxTimeout: CHECKOUT_MUTATION_LOCK_MAX_TIMEOUT_MS,
+      factor: CHECKOUT_MUTATION_LOCK_BACKOFF_FACTOR
+    },
+    description: "Checkout mutation lock"
+  });
+}
+
+// src/core/utils/ci-environment.ts
+function isCiEnvironment(env = process.env) {
+  const ci = (env.CI ?? "").trim().toLowerCase();
+  return ci !== "" && ci !== "false" && ci !== "0" && ci !== "no";
+}
+function isCompeteNonInteractiveEnvironment(env = process.env, stdoutIsTty = Boolean(process.stdout.isTTY)) {
+  return isCiEnvironment(env) || !stdoutIsTty;
+}
+
+// src/core/verification/repair-scope-classifier.ts
+import { createHash as createHash2 } from "crypto";
+var REPAIR_SCOPE_MECHANICAL_MAX_TOTAL_LINE_DELTA = 80;
+var REPAIR_SCOPE_MECHANICAL_MAX_PER_FILE_LINE_DELTA = 40;
+var REPAIR_SCOPE_OFF_SCOPE_MIN_LINE_DELTA = 20;
+var MECHANICAL_PATH_PATTERNS = [/(^|\/)__snapshots__\/.+\.snap$/, /\.snap$/, /\.snapshot$/];
+function isMechanicalRepairPath(filePath) {
+  return isGeneratedLockfilePath(filePath) || MECHANICAL_PATH_PATTERNS.some((pattern) => pattern.test(filePath));
+}
+function normalizeDiffPath(line) {
+  return line.replace(/\t.*$/, "");
+}
+function normalizeDiffBlock(block) {
+  return block.replace(/\r\n/g, "\n").split("\n").filter((line) => !/^index [0-9a-f]+\.\.[0-9a-f]+(?: \d+)?$/i.test(line)).map((line) => {
+    if (line.startsWith("--- ") || line.startsWith("+++ ")) {
+      return normalizeDiffPath(line);
+    }
+    return line;
+  }).join("\n").replace(/\n+$/, "\n");
+}
+function normalizeUnifiedDiffForHash(diff) {
+  const normalized = diff.replace(/\r\n/g, "\n").trim();
+  if (!normalized) return "";
+  const blocks = normalized.split(/(?=^diff --git )/m).map((block) => block.trimEnd()).filter((block) => block.trim().length > 0).map(normalizeDiffBlock).sort((a, b) => a.localeCompare(b));
+  return `${blocks.join("\n")}
+`;
+}
+function hashNormalizedDiff(diff) {
+  return createHash2("sha256").update(normalizeUnifiedDiffForHash(diff)).digest("hex");
+}
+function stripGitPrefix(filePath) {
+  if (filePath === "/dev/null") return filePath;
+  return filePath.replace(/^[ab]\//, "");
+}
+function parseDiffHeaderPath(line) {
+  const match = /^diff --git (.+?) (.+)$/.exec(line);
+  if (!match) return null;
+  const rhs = stripGitPrefix(match[2] ?? "");
+  const lhs = stripGitPrefix(match[1] ?? "");
+  return rhs === "/dev/null" ? lhs : rhs;
+}
+function extractRepairDiffStats(diff) {
+  const statsByPath = /* @__PURE__ */ new Map();
+  let currentPath = null;
+  for (const line of diff.replace(/\r\n/g, "\n").split("\n")) {
+    const headerPath = parseDiffHeaderPath(line);
+    if (headerPath) {
+      currentPath = headerPath;
+      if (!statsByPath.has(currentPath)) {
+        statsByPath.set(currentPath, {
+          path: currentPath,
+          linesAdded: 0,
+          linesDeleted: 0,
+          lineDelta: 0,
+          isNewFile: false,
+          isDeletedFile: false
+        });
+      }
+      continue;
+    }
+    if (!currentPath) continue;
+    const stats = statsByPath.get(currentPath);
+    if (!stats) continue;
+    if (line.startsWith("--- ")) {
+      stats.isNewFile = normalizeDiffPath(line.slice(4)) === "/dev/null";
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      stats.isDeletedFile = normalizeDiffPath(line.slice(4)) === "/dev/null";
+      continue;
+    }
+    if (line.startsWith("+++") || line.startsWith("---")) continue;
+    if (line.startsWith("+")) {
+      stats.linesAdded += 1;
+      stats.lineDelta += 1;
+    } else if (line.startsWith("-")) {
+      stats.linesDeleted += 1;
+      stats.lineDelta += 1;
+    }
+  }
+  return Array.from(statsByPath.values()).sort((a, b) => a.path.localeCompare(b.path));
+}
+function buildRepairDiffSnapshot(diff, commit) {
+  const fileStats = extractRepairDiffStats(diff);
+  const linesAdded = fileStats.reduce((sum, file) => sum + file.linesAdded, 0);
+  const linesDeleted = fileStats.reduce((sum, file) => sum + file.linesDeleted, 0);
+  return {
+    ...commit ? { commit } : {},
+    diffHash: hashNormalizedDiff(diff),
+    files: fileStats.map((file) => file.path),
+    linesAdded,
+    linesDeleted,
+    lineDelta: linesAdded + linesDeleted,
+    fileStats,
+    hashAlgorithm: "sha256",
+    normalization: "normalized-unified-diff-v1"
+  };
+}
+function classifyFromDelta(preRepairDiff, finalDiff, repairDelta) {
+  if (finalDiff.diffHash === preRepairDiff.diffHash) return "none";
+  const outsideStats = finalDiff.fileStats.filter(
+    (file) => repairDelta.filesOutsidePreRepairDiff.includes(file.path)
+  );
+  if (outsideStats.length === 0) return "substantive_in_scope";
+  const mechanicalOutsideStats = outsideStats.filter((file) => isMechanicalRepairPath(file.path));
+  const allOutsideMechanical = mechanicalOutsideStats.length === outsideStats.length;
+  const withinMechanicalBounds = repairDelta.outsideLineDelta <= REPAIR_SCOPE_MECHANICAL_MAX_TOTAL_LINE_DELTA && outsideStats.every((file) => file.lineDelta <= REPAIR_SCOPE_MECHANICAL_MAX_PER_FILE_LINE_DELTA);
+  if (allOutsideMechanical && withinMechanicalBounds) return "mechanical";
+  const hasOutsideDeletion = outsideStats.some((file) => file.linesDeleted > 0);
+  const hasNetNewOutsideFile = outsideStats.some((file) => file.isNewFile);
+  const hasMeaningfulOutsideDelta = repairDelta.outsideLineDelta >= REPAIR_SCOPE_OFF_SCOPE_MIN_LINE_DELTA;
+  const touchesMultipleOutsideFiles = outsideStats.length > 1;
+  if (!allOutsideMechanical && (hasOutsideDeletion || hasNetNewOutsideFile || hasMeaningfulOutsideDelta || touchesMultipleOutsideFiles)) {
+    return "off_scope";
+  }
+  return "scope_expanded";
+}
+function judgeVerdictApplicabilityForRepair(classification) {
+  switch (classification) {
+    case "none":
+    case "mechanical":
+      return "applies";
+    case "substantive_in_scope":
+    case "scope_expanded":
+      return "partially_applies";
+    case "off_scope":
+      return "does_not_apply";
+    case "unknown":
+      return "unknown";
+  }
+}
+function trustForRepairClassification(classification) {
+  switch (classification) {
+    case "none":
+    case "mechanical":
+      return "normal";
+    case "substantive_in_scope":
+    case "scope_expanded":
+      return "warning";
+    case "off_scope":
+      return "quarantined";
+    case "unknown":
+      return "unknown";
+  }
+}
+function analyzeRepairScope(input) {
+  const { preRepairDiff, finalDiff } = input;
+  if (!preRepairDiff || !finalDiff) {
+    return {
+      ...preRepairDiff ? { preRepairDiff } : {},
+      ...finalDiff ? { finalDiff } : {},
+      classification: "unknown",
+      judgeVerdictApplicability: "unknown",
+      finalArtifactTrust: "unknown"
+    };
+  }
+  const preRepairFiles = new Set(preRepairDiff.files);
+  const finalFiles = new Set(finalDiff.files);
+  const filesOutsidePreRepairDiff = finalDiff.files.filter((file) => !preRepairFiles.has(file));
+  const changedFilesInsidePreRepairDiff = finalDiff.files.filter(
+    (file) => preRepairFiles.has(file)
+  );
+  const outsideStats = finalDiff.fileStats.filter((file) => !preRepairFiles.has(file.path));
+  const linesAddedOutsidePreRepairDiff = outsideStats.reduce(
+    (sum, file) => sum + file.linesAdded,
+    0
+  );
+  const linesDeletedOutsidePreRepairDiff = outsideStats.reduce(
+    (sum, file) => sum + file.linesDeleted,
+    0
+  );
+  const outsideLineDelta = linesAddedOutsidePreRepairDiff + linesDeletedOutsidePreRepairDiff;
+  const repairDelta = {
+    filesOutsidePreRepairDiff,
+    changedFilesInsidePreRepairDiff,
+    linesAddedOutsidePreRepairDiff,
+    linesDeletedOutsidePreRepairDiff,
+    outsideLineDelta,
+    preRepairLineDelta: preRepairDiff.lineDelta,
+    finalLineDelta: finalDiff.lineDelta,
+    lineDeltaRatio: outsideLineDelta / Math.max(1, preRepairDiff.lineDelta),
+    mechanicalAllowlistMatches: filesOutsidePreRepairDiff.filter(isMechanicalRepairPath),
+    scopeExpanded: filesOutsidePreRepairDiff.length > 0 || finalFiles.size > preRepairFiles.size
+  };
+  const classification = classifyFromDelta(preRepairDiff, finalDiff, repairDelta);
+  return {
+    preRepairDiff,
+    finalDiff,
+    repairDelta,
+    classification,
+    judgeVerdictApplicability: judgeVerdictApplicabilityForRepair(classification),
+    finalArtifactTrust: trustForRepairClassification(classification)
+  };
+}
+function resolveRepairArtifactPolicy(input) {
+  const classification = input.classification ?? "unknown";
+  if (classification === "off_scope") {
+    if (input.allowOffScopeRepair) {
+      return {
+        action: "warn",
+        finalArtifactTrust: "warning",
+        reason: "off-scope repair allowed by explicit override",
+        overrideAllowed: true,
+        overrideUsed: true
+      };
+    }
+    if (input.effectiveMode === "branch" || input.effectiveMode === "pr") {
+      return {
+        action: "block",
+        finalArtifactTrust: "blocked",
+        reason: `completion-mode=${input.effectiveMode} blocks off-scope repaired artifacts by default`,
+        overrideAllowed: true
+      };
+    }
+    return {
+      action: "quarantine",
+      finalArtifactTrust: "quarantined",
+      reason: "isolated completion retains off-scope repaired artifact for inspection only",
+      overrideAllowed: true
+    };
+  }
+  if (classification === "unknown") {
+    return {
+      action: "warn",
+      finalArtifactTrust: "unknown",
+      reason: "repair scope could not be classified from available diff evidence",
+      overrideAllowed: false
+    };
+  }
+  if (classification === "substantive_in_scope" || classification === "scope_expanded") {
+    return {
+      action: "warn",
+      finalArtifactTrust: "warning",
+      reason: `repair classified as ${classification}`,
+      overrideAllowed: false
+    };
+  }
+  return {
+    action: "allow",
+    finalArtifactTrust: "normal",
+    reason: `repair classified as ${classification}`,
+    overrideAllowed: false
+  };
+}
+
+// src/core/compete/apply-branch-policy.ts
+function resolveBranchApplyBoundary(command, overrides) {
+  return {
+    projectRoot: getExecutionContext().repoRoot || process.cwd(),
+    authority: {
+      command,
+      allowMain: overrides.allowMain,
+      allowProtected: overrides.allowProtected,
+      allowCommingleValidationOutput: overrides.allowCommingleValidationOutput
+    }
+  };
+}
+async function assertLiveWorkspaceMatchesAcceptedArtifact(winner, mode) {
+  if (!winner.worktreePath || !winner.acceptedWorkspaceTreeSha) {
+    return;
+  }
+  const currentSourceTreeSha = await captureCurrentWorkspaceTreeIdentity(winner.worktreePath);
+  if (currentSourceTreeSha !== winner.acceptedWorkspaceTreeSha) {
+    throw new Error(
+      `completion-mode=${mode}: live winner workspace no longer matches the accepted judged artifact (${winner.acceptedWorkspaceTreeSha} -> ${currentSourceTreeSha}). Refusing stale or expanded application.`
+    );
+  }
+  if (mode === "pr") {
+    const headTree = await execGit(["rev-parse", "--verify", "HEAD^{tree}"], {
+      cwd: winner.worktreePath
+    });
+    if (headTree.exitCode !== 0 || headTree.stdout.trim() !== winner.acceptedWorkspaceTreeSha) {
+      throw new Error(
+        `completion-mode=pr: committed HEAD tree at ${winner.worktreePath} could not be verified against the accepted judged artifact (${winner.acceptedWorkspaceTreeSha}). Refusing PR publication.`
+      );
+    }
+  }
+}
+function assertBranchApplyTargetUnchanged(params) {
+  const { authority, expected, observed } = params;
+  if (observed.headSha !== expected.headSha) {
+    throw new Error(
+      `completion-mode=branch: target HEAD changed while resolving the winner patch (${expected.headSha} -> ${observed.headSha ?? "unavailable"}). Refusing stale application.`
+    );
+  }
+  if (observed.branch !== expected.branch) {
+    throw new Error(
+      `completion-mode=branch: target branch changed while resolving the winner patch (${expected.branch ?? "detached HEAD"} -> ${observed.branch ?? "detached HEAD"}). Refusing to apply the winner to a branch that was never policy-checked.`
+    );
+  }
+  if (!authority) {
+    return;
+  }
+  assertBranchAllowsCodeApply({
+    allowMain: authority.allowMain,
+    allowProtected: authority.allowProtected,
+    allowCommingleValidationOutput: authority.allowCommingleValidationOutput,
+    command: authority.command,
+    cwd: params.projectRoot,
+    // 'HEAD' is how the branch policy spells a detached checkout; passing it
+    // explicitly keeps the locked verdict deterministic instead of re-reading
+    // the checkout that was already observed above.
+    currentBranch: observed.branch ?? "HEAD"
+  });
+}
+
+// src/core/compete/judge-winner-line.ts
+var judgeWinnerLine = {
+  announce(winner) {
+    const label = winner.matrixRecountLabel;
+    if (!label) return `Judge winner: ${winner.variantId}`;
+    return `Judge winner: ${winner.variantId}; ${label}`;
+  },
+  presentation(winner) {
+    return winner.matrixRecountLabel ? { matrixRecountLabel: winner.matrixRecountLabel } : {};
+  },
+  pr(variantId, label) {
+    return `Judge winner: \`${variantId}\`${label ? `; ${label}` : ""}.`;
+  }
+};
+
+// src/core/compete/apply-pr-body.ts
+var TASK_SUMMARY_MAX_CHARS = 600;
+function quoteTaskSummary(prompt) {
+  const trimmed = prompt.trim();
+  const excerpt = trimmed.length > TASK_SUMMARY_MAX_CHARS ? `${trimmed.slice(0, TASK_SUMMARY_MAX_CHARS).trimEnd()} ...` : trimmed;
+  return excerpt.split(/\r?\n/).map((line) => line.trim() ? `> ${line}` : ">");
+}
+function buildPrBody(input) {
+  const lines = ["## Summary", `Delivery artifact: \`${input.variantId}\`.`];
+  if (input.taskPrompt?.trim()) {
+    lines.push("", "## Task", ...quoteTaskSummary(input.taskPrompt));
+  }
+  const source = [];
+  if (input.judgeWinnerId) {
+    source.push(judgeWinnerLine.pr(input.judgeWinnerId, input.matrixRecountLabel));
+  }
+  if (input.substitutionReason) source.push(`Delivery reason: ${input.substitutionReason}`);
+  const contributors = input.synthesisContributors?.filter((id) => id.trim()) ?? [];
+  if (contributors.length > 0) {
+    source.push(`Synthesis contributors: ${contributors.map((id) => `\`${id}\``).join(", ")}`);
+  }
+  if (source.length > 0) lines.push("", "## Delivery source", ...source);
+  if (input.verificationSummary) {
+    lines.push("", "## Verification", input.verificationSummary);
+  }
+  const details = [];
+  if (input.taskId) details.push(`- Task ID: \`${input.taskId}\``);
+  if (input.judge) details.push(`- Judge: \`${input.judge}\``);
+  if (input.completionMode) details.push(`- Completion mode: \`${input.completionMode}\``);
+  if (input.variantCount) details.push(`- Variants evaluated: ${input.variantCount}`);
+  if (details.length > 0) lines.push("", ...details);
+  return `${lines.join("\n")}
+`;
+}
+
+// src/core/compete/patch-delivery-eligibility.ts
+import { posix } from "path";
+function pathsCreatedByPatch(patch) {
+  const created = /* @__PURE__ */ new Set();
+  let current;
+  for (const line of patch.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      current = parseDiffGitHeaderPaths(line)?.bPath.replace(/\\/g, "/");
+    } else if (current && line.startsWith("new file mode ")) {
+      created.add(current);
+    }
+  }
+  return created;
+}
+function assertPatchPathsAreDeliveryEligible(patch, projectRoot, errorPrefix) {
+  const trackedRoots = readTrackedToolOutputRootsSync(projectRoot);
+  const specialMode = patch.match(
+    /^(?:(?:new file mode|new mode) (120000|160000)|index [0-9a-f]+\.\.[0-9a-f]+ (120000|160000))$/m
+  );
+  const specialModeValue = specialMode?.[1] ?? specialMode?.[2];
+  if (specialModeValue) {
+    throw new Error(
+      `${errorPrefix}: accepted artifact contains special Git object mode ${specialModeValue}.`
+    );
+  }
+  const createdPaths = pathsCreatedByPatch(patch);
+  const patchProbe = {
+    isNestedToolOutputDir: (candidate) => trackedRoots.isNestedToolOutputDir?.(candidate, createdPaths) ?? false
+  };
+  for (const line of patch.split("\n")) {
+    let paths = [];
+    if (line.startsWith("diff --git ")) {
+      const parsed = parseDiffGitHeaderPaths(line);
+      if (!parsed) {
+        throw new Error(
+          `${errorPrefix}: could not validate a diff header path. Refusing an unscoped patch.`
+        );
+      }
+      paths = [parsed.aPath, parsed.bPath];
+    } else if (line.startsWith("--- ") || line.startsWith("+++ ")) {
+      const parsed = parseUnifiedDiffPathLine(line);
+      if (parsed && parsed !== "/dev/null") paths = [parsed];
+    }
+    for (const patchPath of paths) {
+      const normalized = patchPath.replace(/\\/g, "/");
+      if (normalized === ".gitmodules") {
+        throw new Error(
+          `${errorPrefix}: accepted artifact contains .gitmodules. Refusing repository-level submodule configuration.`
+        );
+      }
+      if (posix.isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../") || normalized.includes("/../")) {
+        throw new Error(
+          `${errorPrefix}: accepted artifact contains unsafe path ${patchPath}. Refusing to apply bytes outside the repository.`
+        );
+      }
+      const created = createdPaths.has(normalized);
+      if (shouldExcludeStatusPath(patchPath, created, trackedRoots) || created && isUnderNestedToolOutputDir(normalized, patchProbe, createdPaths)) {
+        throw new Error(
+          `${errorPrefix}: accepted artifact contains excluded path ${patchPath}. Refusing to apply bytes outside the delivery-eligible artifact.`
+        );
+      }
+    }
+  }
+}
+
+// src/core/compete/post-apply-label.ts
+function derivePostApplyDisposition(report, changedFiles) {
+  if (!report || report.status !== "unavailable" && report.status !== "not_run") return void 0;
+  return deriveVerificationDisposition({
+    passed: report.status === "not_run",
+    unavailable: true,
+    // Without applied-file provenance the evaluation covers the whole project.
+    scope: changedFiles && changedFiles.length > 0 ? "task" : "project",
+    reason: report.reason
+  });
+}
+function formatPostApplyUnverifiedLabel(report, changedFiles) {
+  const disposition = derivePostApplyDisposition(report, changedFiles);
+  return disposition ? formatUnverifiedDeliveryLabel(disposition)?.replace(/^Delivered,/, "Applied,") : void 0;
+}
+function formatApplicationVerificationLine(application) {
+  const report = application?.postApplyVerification;
+  if (!application || !report?.status) return void 0;
+  const label = formatPostApplyUnverifiedLabel(
+    { status: report.status, reason: report.reason },
+    application.changedFiles
+  );
+  return `Application: ${label ?? `${application.status ?? "applied"}; post-apply verification ${report.status}`}`;
+}
+
+// src/core/compete/post-apply-verification.ts
+var NO_VERIFICATION_SURFACE_NOTE = "no verification surface";
+function shouldRefusePostApplyVerification(verification) {
+  return verification.status === "failed";
+}
+function commitRefsMatch(left, right) {
+  const a = left.trim().toLowerCase();
+  const b = right.trim().toLowerCase();
+  return a === b || a.length >= 7 && b.startsWith(a) || b.length >= 7 && a.startsWith(b);
+}
+function deriveBaselineFailureEvidence(result) {
+  const baselineRef = result.baselineComparison?.baselineRef?.trim();
+  if (!baselineRef) return void 0;
+  const verification = readVariantVerification(result);
+  if (verification.status !== "baseline_clean") return void 0;
+  const gates = gatesAlsoFailingOnBase(verification.gates);
+  return gates.length > 0 ? { baselineRef, gates } : void 0;
+}
+function acceptBaselineKnownFailure(report, evidence, targetHeadSha) {
+  if (report.status !== "failed" || !evidence || !commitRefsMatch(evidence.baselineRef, targetHeadSha)) {
+    return report;
+  }
+  const failing = (report.commands ?? []).filter(
+    (c) => c.classification !== "passed" && c.classification !== "unavailable"
+  );
+  const sameAsBase = failing.length > 0 && failing.every((c) => c.classification === "failed" && evidence.gates.includes(c.channel));
+  if (!sameAsBase) return report;
+  const channels = [...new Set(failing.map((c) => c.channel))].join(", ");
+  return {
+    status: "unavailable",
+    reason: `${channels} fails the same way on the base commit`,
+    commands: report.commands
+  };
+}
+function resolvePostApplyVerificationSurface(input) {
+  const channels = [
+    ["build", input.scope.build],
+    ["lint", input.scope.lint],
+    ["test", input.scope.test]
+  ];
+  const selected = channels.flatMap(
+    ([channel, resolved]) => (resolved.availability === "relevant" ? resolved.commands : resolved.partialCommands ?? []).map((command) => ({ channel, command }))
+  );
+  const unavailableChannels = channels.filter(([, resolved]) => resolved.availability === "unavailable").map(
+    ([channel, resolved]) => resolved.uncovered?.length ? `${channel} (no ${resolved.uncovered.join(", ")} coverage)` : channel
+  );
+  if (unavailableChannels.length > 0) {
+    return {
+      selected,
+      noSurface: {
+        status: "unavailable",
+        reason: `Capability-resolved verification is unavailable for ${unavailableChannels.join(
+          ", "
+        )} on the applied files; cannot verify.`
+      }
+    };
+  }
+  if (selected.length === 0) {
+    return {
+      selected: [],
+      noSurface: {
+        status: "not_run",
+        reason: NO_VERIFICATION_SURFACE_NOTE
+      }
+    };
+  }
+  return { selected };
+}
+function resolvePostApplyVerificationFromOutcomes(outcomes) {
+  const aggregate = aggregateResolverOutcomes(outcomes);
+  const commandEvidence = outcomes.map(({ channel, command, classification, durationMs }) => ({
+    channel,
+    command,
+    classification,
+    durationMs
+  }));
+  if (aggregate.classification === "passed") {
+    const unmeasured = outcomes.some((outcome) => outcome.unmeasured === true);
+    const suffix = unmeasured ? " (unmeasured)" : "";
+    return {
+      status: "passed",
+      reason: `Passed ${outcomes.length} capability-resolved verification command(s)${suffix}.`,
+      commands: commandEvidence
+    };
+  }
+  if (aggregate.classification === "unavailable") {
+    return {
+      status: "unavailable",
+      reason: aggregate.representative?.message ?? `${NO_VERIFICATION_SURFACE_NOTE}: capability-resolved post-apply verification produced no usable evidence.`,
+      commands: commandEvidence
+    };
+  }
+  return {
+    status: "failed",
+    reason: aggregate.representative?.message ?? "Capability-resolved post-apply verification produced no usable evidence.",
+    commands: commandEvidence
+  };
+}
+async function verifyAppliedBranch(projectRoot, changedFiles, timeoutMinutes) {
+  const scope = resolveVerificationChannelScope(projectRoot, changedFiles);
+  const surface = resolvePostApplyVerificationSurface({ scope, changedFiles });
+  if (surface.noSurface && surface.selected.length === 0) return surface.noSurface;
+  const outcomes = [];
+  for (const { channel, command } of surface.selected) {
+    const startedAt = Date.now();
+    const result = await runVerificationCommand(command, {
+      cwd: projectRoot,
+      timeoutMs: timeoutMinutes !== void 0 ? timeoutMinutes * 6e4 : DEFAULT_TIMEOUT_MS
+    });
+    outcomes.push({
+      ...classifyResolverCommand(command, result, Date.now() - startedAt, { bucket: channel }),
+      channel
+    });
+  }
+  const report = resolvePostApplyVerificationFromOutcomes(outcomes);
+  return surface.noSurface && report.status === "passed" ? { ...surface.noSurface, commands: report.commands } : report;
+}
+
+// src/core/compete/verify-pr-publication.ts
+import { existsSync } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join4 } from "path";
+var FULL_OBJECT_ID = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/i;
+function refuse(cwd, reason) {
+  throw new Error(
+    `completion-mode=pr: ${reason} (${cwd}). Refusing PR publication; candidate retained.`
+  );
+}
+async function resolveObject(cwd, ref, kind) {
+  const result = await execGit(["rev-parse", "--verify", "--end-of-options", `${ref}^{${kind}}`], {
+    cwd
+  });
+  const sha = result.stdout.trim();
+  if (result.exitCode !== 0 || !FULL_OBJECT_ID.test(sha)) {
+    refuse(cwd, `could not resolve publication ${kind}`);
+  }
+  return sha;
+}
+async function assertAcceptedPatch(artifact, projectRoot, cwd, sourceHeadSha) {
+  const baseline = artifact.baselineRef?.trim();
+  const patch = artifact.worktreeDiffReplayable === true && artifact.worktreeDiff ? artifact.worktreeDiff : artifact.artifactManifest ? await readArtifactDiffFromManifestPath(artifact.artifactManifest, projectRoot, true) : void 0;
+  if (!baseline || !FULL_OBJECT_ID.test(baseline) || !patch) {
+    refuse(cwd, "no accepted tree or trusted replayable patch with an immutable baseline");
+  }
+  const baseSha = await resolveObject(cwd, baseline, "commit");
+  if (baseSha !== baseline.toLowerCase())
+    refuse(cwd, "accepted patch baseline could not be verified");
+  const scratch = await mkBuildTempDir("pr-publication-witness");
+  try {
+    const patchPath = join4(scratch, "committed.patch");
+    const diff = await execGit(
+      [
+        "diff",
+        "--binary",
+        "--full-index",
+        "--no-color",
+        "--no-ext-diff",
+        "--no-textconv",
+        "--no-relative",
+        "--src-prefix=a/",
+        "--dst-prefix=b/",
+        `--output=${patchPath}`,
+        baseSha,
+        sourceHeadSha,
+        "--"
+      ],
+      { cwd, timeoutMs: 6e4 }
+    );
+    if (diff.exitCode !== 0 && diff.exitCode !== 1) {
+      refuse(cwd, "could not read the full committed diff for the accepted patch");
+    }
+    const committedPatch = await readFile2(patchPath);
+    if (!committedPatch.equals(Buffer.from(patch, "utf8"))) {
+      refuse(cwd, "committed source is not byte-identical to the accepted replayable patch");
+    }
+  } finally {
+    await safeRmDir(scratch, { protectedPaths: [tmpdir()], managedRoots: [tmpdir()] });
+  }
+}
+async function verifyPrPublicationSource(artifact, projectRoot, branchName) {
+  const worktreePath = artifact.worktreePath && existsSync(artifact.worktreePath) ? artifact.worktreePath : void 0;
+  const cwd = worktreePath ?? projectRoot;
+  const sourceHeadSha = await resolveObject(
+    cwd,
+    worktreePath ? "HEAD" : `refs/heads/${branchName}`,
+    "commit"
+  );
+  const committedTree = await resolveObject(cwd, sourceHeadSha, "tree");
+  if (artifact.acceptedWorkspaceTreeSha) {
+    if (committedTree !== artifact.acceptedWorkspaceTreeSha) {
+      refuse(cwd, "committed source tree does not match the accepted judged artifact");
+    }
+  } else {
+    await assertAcceptedPatch(artifact, projectRoot, cwd, sourceHeadSha);
+  }
+  if (worktreePath && await captureCurrentWorkspaceTreeIdentity(worktreePath) !== committedTree) {
+    refuse(cwd, "live winner workspace no longer matches the accepted judged artifact");
+  }
+  return { cwd, sourceHeadSha };
+}
+
+// src/core/compete/apply-completion-mode.ts
+var COMPETE_DIFF_BINARY_FLAGS = ["--binary", "--full-index"];
+var COMPETE_GIT_APPLY_WHITESPACE_FLAGS = ["--whitespace=nowarn"];
+var COMPETE_DIFF_MAX_BUFFER_BYTES = 256 * 1024 * 1024;
+var APPLY_GIT_TIMEOUT_MS = 6e4;
+var TRUNCATED_DIFF_MARKERS = [
+  /^(?:\.\.\. ?)?\[(?:\.\.\. )?diff truncated\b[^\]\n]*\](?: \.\.\.)?[ \t]*$/im,
+  /^\.\.\. \[diff truncated(?:[^\]]*)\](?:[;,]|$)/im,
+  /^\[Note: .*diff truncated.*\]$/im,
+  /^NOTE: Diff truncated/im,
+  /^\.\.\.\[output truncated:/im
+];
+function isRecoverableCompetitionDiff(diff) {
+  if (diff.trim().length === 0) return false;
+  return !TRUNCATED_DIFF_MARKERS.some((marker) => marker.test(diff));
+}
+var PR_REMOTE_OP_TIMEOUT_MS = 3e5;
+function resolveEffectiveCompletionMode(mode, context) {
+  let effectiveMode = mode === "none" ? "isolated" : mode;
+  if (effectiveMode === "auto") {
+    if (context.autoModePreference !== void 0) {
+      effectiveMode = context.autoModePreference;
+    } else {
+      effectiveMode = "isolated";
+    }
+  }
+  if (context.createPr === false && effectiveMode === "pr") {
+    effectiveMode = "isolated";
+  }
+  return effectiveMode;
+}
+var CompletionModeCancelledError = class extends Error {
+  constructor(mode, variantId) {
+    super(`completion-mode=${mode} cancelled by user for ${variantId}`);
+    this.name = "CompletionModeCancelledError";
+  }
+};
+function getBranchModeAckPath(projectRoot) {
+  return join5(projectRoot, ".build-project", "state", "branch-mode-ack");
+}
+function hasBranchModeAck(projectRoot) {
+  return existsSync2(getBranchModeAckPath(projectRoot));
+}
+function writeBranchModeAck(projectRoot) {
+  const ackPath = getBranchModeAckPath(projectRoot);
+  mkdirSync(join5(projectRoot, ".build-project", "state"), { recursive: true });
+  writeFileSync(ackPath, (/* @__PURE__ */ new Date()).toISOString(), "utf8");
+}
+function isWorkingTreeClean(projectRoot) {
+  try {
+    return readStatusChangedFiles(projectRoot, ["--untracked-files=all"]).every(
+      (filePath) => filePath === ".build-project/merge-apply" || filePath.startsWith(".build-project/merge-apply/")
+    );
+  } catch {
+    return false;
+  }
+}
+function resolveWinnerBranchName(winner) {
+  if (winner.branchName?.trim()) {
+    return winner.branchName.trim();
+  }
+  if (!winner.worktreePath) {
+    return void 0;
+  }
+  try {
+    const output = parseCurrentBranchRef(
+      execGitSyncChecked([...CURRENT_BRANCH_REV_PARSE_ARGS], {
+        cwd: winner.worktreePath,
+        timeoutMs: APPLY_GIT_TIMEOUT_MS
+      }).stdout
+    );
+    if (!output || output === "HEAD") {
+      return void 0;
+    }
+    return output;
+  } catch {
+    return void 0;
+  }
+}
+function readGitOutput(projectRoot, args) {
+  try {
+    const output = execGitSyncChecked(args, {
+      cwd: projectRoot,
+      timeoutMs: APPLY_GIT_TIMEOUT_MS
+    }).stdout.trim();
+    return output || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function normalizePatchForGitApply(patch) {
+  return patch.endsWith("\n") ? patch : `${patch}
+`;
+}
+function readGitHead(projectRoot) {
+  return readGitOutput(projectRoot, ["rev-parse", "HEAD"]);
+}
+function readGitBranch(projectRoot) {
+  const branch = readGitOutput(projectRoot, [...CURRENT_BRANCH_REV_PARSE_ARGS]);
+  const name = branch ? parseCurrentBranchRef(branch) : void 0;
+  return name && name !== "HEAD" ? name : void 0;
+}
+function readWinnerHead(winner, projectRoot) {
+  if (winner.worktreePath) {
+    const worktreeHead = readGitHead(winner.worktreePath);
+    if (worktreeHead) return worktreeHead;
+  }
+  const branchName = resolveWinnerBranchName(winner);
+  return branchName ? readGitOutput(projectRoot, ["rev-parse", branchName]) : void 0;
+}
+function readStatusChangedFiles(projectRoot, extraArgs = []) {
+  const { stdout } = execGitSyncChecked(["status", "--porcelain", "-z", ...extraArgs], {
+    cwd: projectRoot,
+    timeoutMs: APPLY_GIT_TIMEOUT_MS,
+    stripFinalNewline: false
+  });
+  return [...new Set(parsePorcelainEntriesZ(stdout).map((entry) => entry.path))].sort();
+}
+function parsePrNumberFromGhCreateOutput(output) {
+  const trimmed = String(output).trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const githubUrlMatch = trimmed.match(/\/pull\/(\d+)(?:\b|$)/);
+  if (githubUrlMatch?.[1]) {
+    return Number.parseInt(githubUrlMatch[1], 10);
+  }
+  const hashMatch = trimmed.match(/#(\d+)\b/);
+  if (hashMatch?.[1]) {
+    return Number.parseInt(hashMatch[1], 10);
+  }
+  return void 0;
+}
+async function applyIsolated(winner, context) {
+  if (winner.worktreePath) {
+    console.log(
+      `Artifact ${winner.variantId} retained at: ${winner.worktreePath} (no target changes applied)`
+    );
+  } else {
+    console.log(`Artifact: ${winner.variantId} (retained; no target changes applied)`);
+  }
+  const classification = winner.repairOutcome?.classification;
+  if (classification === "off_scope") {
+    console.log(`Final artifact: ${winner.repairOutcome?.finalArtifactTrust ?? "quarantined"}`);
+    console.log("Judge verdict applies to final artifact: no");
+  } else if (classification === "unknown") {
+    console.log("Final artifact: unknown repair scope");
+  }
+  context.onApplied?.({
+    mode: "isolated",
+    variantId: winner.variantId,
+    taskId: context.taskId
+  });
+}
+async function applyPr(winner, context) {
+  const branchName = resolveWinnerBranchName(winner);
+  if (!branchName) {
+    console.warn("completion-mode=pr: winner has no branch; falling back to isolated.");
+    await applyIsolated(winner, context);
+    return;
+  }
+  winner.branchName = branchName;
+  const publication = await verifyPrPublicationSource(winner, context.projectRoot, branchName);
+  console.log(`Pushing delivery branch: ${branchName}`);
+  try {
+    execGitSyncChecked(
+      ["push", "origin", `${publication.sourceHeadSha}:refs/heads/${branchName}`],
+      {
+        cwd: publication.cwd,
+        // Bound the push so it cannot hang forever on a credential/auth prompt
+        // (FIX #7). Other apply git calls already use 30s/60s timeouts.
+        timeoutMs: PR_REMOTE_OP_TIMEOUT_MS,
+        // Fail fast instead of blocking on an interactive credential prompt.
+        // Only this override is passed: the shared primitive supplies the base
+        // environment with the ambient git repository variables removed, so a
+        // hook-supplied GIT_DIR cannot redirect the push.
+        env: { GIT_TERMINAL_PROMPT: "0" }
+      }
+    );
+    const prCreateOutput = execFileSync(
+      "gh",
+      [
+        "pr",
+        "create",
+        "--head",
+        branchName,
+        "--title",
+        `Build: deliver ${winner.variantId}`,
+        "--body",
+        buildPrBody({
+          ...context.deliveryPresentation,
+          variantId: winner.variantId,
+          verificationSummary: winner.verificationSummary,
+          synthesisContributors: winner.synthesisContributors,
+          taskId: context.taskId,
+          judge: context.resolvedConfig?.judge,
+          completionMode: context.resolvedConfig?.completionMode,
+          variantCount: context.allVariants?.length
+        })
+      ],
+      {
+        cwd: context.projectRoot,
+        encoding: "utf8",
+        // Bound remote operations and disable interactive auth prompts (FIX #7).
+        timeout: PR_REMOTE_OP_TIMEOUT_MS,
+        env: { ...process.env, GH_PROMPT_DISABLED: "1" }
+      }
+    );
+    const prNumber = parsePrNumberFromGhCreateOutput(prCreateOutput);
+    if (typeof prNumber === "number" && Number.isFinite(prNumber)) {
+      winner.prNumber = prNumber;
+    }
+    console.log(`Pull request created for ${winner.variantId}`);
+    context.onApplied?.({
+      mode: "pr",
+      variantId: winner.variantId,
+      taskId: context.taskId,
+      prNumber,
+      sourceHeadSha: publication.sourceHeadSha,
+      sourceBranch: branchName
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`Failed to create PR: ${msg}`);
+    throw err;
+  }
+}
+function parseAddedFilePathsFromPatch(patch) {
+  const lines = patch.split("\n");
+  const added = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === "--- /dev/null" || line?.startsWith("--- /dev/null	")) {
+      const next = lines[i + 1];
+      if (next?.startsWith("+++ ")) {
+        const decoded = decodePatchPath(next.slice(4));
+        if (decoded) {
+          added.push(decoded);
+        }
+      }
+    }
+  }
+  return added;
+}
+function decodePatchPath(field) {
+  let raw = field.split("	")[0]?.trim() ?? "";
+  if (!raw || raw === "/dev/null") {
+    return void 0;
+  }
+  if (raw.startsWith('"') && raw.endsWith('"') && raw.length >= 2) {
+    raw = decodeGitQuotedPathBody(raw.slice(1, -1));
+  }
+  if (raw.startsWith("a/") || raw.startsWith("b/")) {
+    raw = raw.slice(2);
+  }
+  return raw.length > 0 ? raw : void 0;
+}
+function rollbackFailedApply(projectRoot, baseSha, patch) {
+  try {
+    execGitSyncChecked(["reset", "--hard", baseSha], {
+      cwd: projectRoot,
+      timeoutMs: APPLY_GIT_TIMEOUT_MS
+    });
+    const addedPaths = parseAddedFilePathsFromPatch(patch);
+    if (addedPaths.length > 0) {
+      const literalPathspecs = addedPaths.map((path4) => `:(literal)${path4}`);
+      execGitSyncChecked(["clean", "-d", "-f", "--", ...literalPathspecs], {
+        cwd: projectRoot,
+        timeoutMs: APPLY_GIT_TIMEOUT_MS
+      });
+    }
+  } catch (rollbackErr) {
+    const rollbackMsg = rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr);
+    throw new Error(
+      `Error: failed to roll back working tree after a failed apply: ${rollbackMsg}. The working tree may be in a partial state. Recover manually with: git reset --hard ${baseSha} && git clean -d -f`
+    );
+  }
+}
+async function applyBranch(winner, modeSource, context) {
+  const inCi = context.isCi ?? isCompeteNonInteractiveEnvironment();
+  if (inCi && modeSource !== "flag" && modeSource !== "env") {
+    throw new Error(
+      "completion-mode=branch requires explicit opt-in in CI. Use --completion-mode branch or BUILD_COMPLETION_MODE=branch to enable."
+    );
+  }
+  if (!isWorkingTreeClean(context.projectRoot)) {
+    throw new Error(
+      "completion-mode=branch requires a clean working tree. Commit or stash your changes first."
+    );
+  }
+  const baseSha = execGitSyncChecked(["rev-parse", "HEAD"], {
+    cwd: context.projectRoot,
+    timeoutMs: APPLY_GIT_TIMEOUT_MS
+  }).stdout.trim();
+  const targetBranch = readGitBranch(context.projectRoot);
+  if (!inCi && !hasBranchModeAck(context.projectRoot)) {
+    if (process.stdout.isTTY) {
+      const readline = await import("readline");
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const answer = await new Promise((resolve3) => {
+        rl.question(
+          "completion-mode=branch will apply changes directly to your current branch.\nThis is a one-time confirmation per repo. Continue? [y/N] ",
+          (ans) => {
+            rl.close();
+            resolve3(ans.trim().toLowerCase());
+          }
+        );
+      });
+      if (!isYesAnswer(answer)) {
+        console.log("Aborted.");
+        throw new CompletionModeCancelledError("branch", winner.variantId);
+      }
+      writeBranchModeAck(context.projectRoot);
+    }
+  }
+  console.log(`Applying ${winner.variantId} changes to current branch...`);
+  const baselineRef = winner.baselineRef?.trim();
+  if (!baselineRef) {
+    throw new Error(
+      `completion-mode=branch: winner ${winner.variantId} is missing a trustworthy baselineRef. Refusing to apply without proving the target branch is still at the competition base.`
+    );
+  }
+  if (!commitRefsMatch(baselineRef, baseSha)) {
+    throw new Error(
+      `completion-mode=branch: target HEAD moved since the competition started (expected ${baselineRef}, found ${baseSha}). Refusing to reverse or overwrite concurrent commits.`
+    );
+  }
+  const sourceBranch = resolveWinnerBranchName(winner);
+  const sourceHeadSha = readWinnerHead(winner, context.projectRoot);
+  let applyAttempted = false;
+  let releaseCheckoutMutationLock;
+  let patchOutput = "";
+  let appliedEvent;
+  try {
+    let source = "none";
+    let artifactDiff;
+    if (winner.worktreePath) {
+      let intentIndex;
+      try {
+        intentIndex = await prepareUntrackedIntentIndex({
+          worktreePath: winner.worktreePath
+        });
+      } catch (prepareErr) {
+        if (existsSync2(winner.worktreePath)) {
+          const prepareMsg = prepareErr instanceof Error ? prepareErr.message : String(prepareErr);
+          throw new Error(
+            `completion-mode=branch: failed to stage untracked winner files for the diff from worktree ${winner.worktreePath}: ${prepareMsg}. Refusing to apply a patch that would silently omit newly created files.`
+          );
+        }
+      }
+      try {
+        patchOutput = filterDeliveryPatchByExcludedPaths(
+          execGitSyncChecked(["diff", ...COMPETE_DIFF_BINARY_FLAGS, "--no-color", baseSha], {
+            cwd: winner.worktreePath,
+            maxBuffer: COMPETE_DIFF_MAX_BUFFER_BYTES,
+            timeoutMs: APPLY_GIT_TIMEOUT_MS,
+            // Verbatim: the runner's default newline strip takes a trailing
+            // "\r\n" in full, so a CRLF winner's last line would lose its CR
+            // (normalizePatchForGitApply re-adds "\n" only) and apply as
+            // different bytes than the winner produced.
+            stripFinalNewline: false,
+            // Read against the temp index so untracked files render as new-file
+            // blocks. Omitted when there were none, keeping the no-untracked-work
+            // case byte-identical to previous behavior. Only GIT_INDEX_FILE is
+            // passed: the shared primitive's base environment already has the
+            // ambient git repository variables removed, so the diff cannot be
+            // redirected to a hook's repository or index.
+            ...intentIndex?.indexPath ? { env: { GIT_INDEX_FILE: intentIndex.indexPath } } : {}
+          }).stdout
+        );
+        source = "worktree";
+      } catch (diffErr) {
+        const worktreeMissing = !existsSync2(winner.worktreePath);
+        if (!worktreeMissing) {
+          const diffMsg = diffErr instanceof Error ? diffErr.message : String(diffErr);
+          throw new Error(
+            `completion-mode=branch: failed to read the winner diff from worktree ${winner.worktreePath}: ${diffMsg}. Refusing to fall back to a possibly-stale cached diff because the worktree is present but the diff could not be read.`
+          );
+        }
+      } finally {
+        await intentIndex?.dispose();
+      }
+    }
+    let acceptedDiff;
+    if (winner.worktreeDiff && isRecoverableCompetitionDiff(winner.worktreeDiff)) {
+      acceptedDiff = winner.worktreeDiff;
+    } else if (winner.artifactManifest) {
+      acceptedDiff = await readArtifactDiffFromManifestPath(winner.artifactManifest, context.projectRoot) ?? void 0;
+    }
+    const legacyByteIdentity = source === "worktree" && acceptedDiff !== void 0 && normalizePatchForGitApply(patchOutput) === normalizePatchForGitApply(acceptedDiff);
+    if (acceptedDiff)
+      assertPatchPathsAreDeliveryEligible(
+        acceptedDiff,
+        context.projectRoot,
+        "completion-mode=branch"
+      );
+    if (source === "worktree" && patchOutput.trim() && !winner.acceptedWorkspaceTreeSha && !legacyByteIdentity) {
+      throw new Error(
+        acceptedDiff ? "completion-mode=branch: live winner diff is not byte-identical to the accepted eligible artifact and has no accepted workspace-tree identity. Refusing stale or expanded application." : "completion-mode=branch: live winner has no accepted cached or persisted artifact identity (workspace-tree identity unavailable). Refusing to apply an unverified live worktree state."
+      );
+    }
+    if (source === "none" && winner.worktreeDiffReplayable !== false && winner.worktreeDiff && isRecoverableCompetitionDiff(winner.worktreeDiff)) {
+      patchOutput = winner.worktreeDiff;
+      source = "cached-diff";
+    }
+    if (source === "none" && winner.artifactManifest) {
+      artifactDiff ??= await readArtifactDiffFromManifestPath(
+        winner.artifactManifest,
+        context.projectRoot,
+        true
+      ) ?? void 0;
+      if (artifactDiff && isRecoverableCompetitionDiff(artifactDiff)) {
+        patchOutput = artifactDiff;
+        source = "artifact";
+      }
+    }
+    if (source === "none") {
+      throw new Error(
+        `completion-mode=branch: winner ${winner.variantId} has no worktree path, cached diff, or artifact diff for application.`
+      );
+    }
+    assertPatchPathsAreDeliveryEligible(patchOutput, context.projectRoot, "completion-mode=branch");
+    if (source === "worktree") {
+      await assertLiveWorkspaceMatchesAcceptedArtifact(winner, "branch");
+    }
+    if (!patchOutput.trim()) {
+      console.log("Winner has no changes relative to HEAD \u2014 nothing to apply.");
+      context.onApplied?.({
+        mode: "branch",
+        variantId: winner.variantId,
+        taskId: context.taskId,
+        appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sourceBranch,
+        sourceHeadSha,
+        targetBranch,
+        targetPreApplyHeadSha: baseSha,
+        targetPostApplyHeadSha: baseSha,
+        diffSource: source,
+        changedFiles: [],
+        filesChanged: 0,
+        reason: "empty_diff"
+      });
+      return;
+    }
+    patchOutput = normalizePatchForGitApply(patchOutput);
+    releaseCheckoutMutationLock = await acquireCheckoutMutationLock(context.projectRoot);
+    await releaseCheckoutMutationLock.assertOwned();
+    if (!isWorkingTreeClean(context.projectRoot)) {
+      throw new Error(
+        "completion-mode=branch: target working tree changed while resolving the winner patch. Refusing to mix concurrent edits into the apply transaction."
+      );
+    }
+    assertBranchApplyTargetUnchanged({
+      expected: { branch: targetBranch, headSha: baseSha },
+      observed: {
+        branch: readGitBranch(context.projectRoot),
+        headSha: readGitHead(context.projectRoot)
+      },
+      projectRoot: context.projectRoot,
+      authority: context.branchApplyAuthority
+    });
+    await releaseCheckoutMutationLock.assertOwned();
+    applyAttempted = true;
+    execGitSyncChecked(["apply", "--3way", ...COMPETE_GIT_APPLY_WHITESPACE_FLAGS], {
+      cwd: context.projectRoot,
+      input: patchOutput,
+      timeoutMs: APPLY_GIT_TIMEOUT_MS
+    });
+    await releaseCheckoutMutationLock.assertOwned();
+    const targetPostApplyHeadSha = readGitHead(context.projectRoot);
+    const changedFiles = readStatusChangedFiles(context.projectRoot);
+    console.log(
+      source === "cached-diff" ? `Applied ${winner.variantId} changes to current branch (from cached diff).` : source === "artifact" ? `Applied ${winner.variantId} changes to current branch (from artifact diff).` : `Applied ${winner.variantId} changes to current branch.`
+    );
+    appliedEvent = {
+      mode: "branch",
+      variantId: winner.variantId,
+      taskId: context.taskId,
+      appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sourceBranch,
+      sourceHeadSha,
+      targetBranch,
+      targetPreApplyHeadSha: baseSha,
+      targetPostApplyHeadSha,
+      diffSource: source,
+      changedFiles,
+      filesChanged: changedFiles.length
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`Error: failed to apply changes: ${msg}`);
+    if (applyAttempted) {
+      try {
+        if (releaseCheckoutMutationLock) {
+          await releaseCheckoutMutationLock.assertOwned();
+        }
+        rollbackFailedApply(context.projectRoot, baseSha, patchOutput);
+        console.log(`Info: rolled back working tree to ${baseSha} after failed apply.`);
+      } catch (rollbackErr) {
+        const rollbackMsg = rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr);
+        console.error(
+          rollbackErr instanceof FileLockCompromisedError ? `Warning: checkout lock ownership was lost; rollback was skipped and the target tree may be partially applied at ${context.projectRoot}. ${rollbackMsg}` : rollbackMsg
+        );
+      }
+    }
+    throw err;
+  } finally {
+    if (releaseCheckoutMutationLock) {
+      await releaseCheckoutMutationLock().catch(() => void 0);
+      releaseCheckoutMutationLock = void 0;
+    }
+  }
+  if (!appliedEvent) return;
+  context.onApplicationFact?.(appliedEvent);
+  const postApplyVerification = acceptBaselineKnownFailure(
+    await verifyAppliedBranch(
+      context.projectRoot,
+      appliedEvent.changedFiles ?? [],
+      context.resolvedConfig?.timeout
+    ),
+    winner.baselineFailureEvidence,
+    baseSha
+  );
+  const verifiedEvent = { ...appliedEvent, postApplyVerification };
+  context.onApplied?.(verifiedEvent);
+  if (shouldRefusePostApplyVerification(postApplyVerification)) {
+    throw new Error(
+      `completion-mode=branch post-apply verification ${postApplyVerification.status}: ${postApplyVerification.reason}. The applied changes were left in the working tree for inspection.`
+    );
+  }
+  const unverifiedLabel = formatPostApplyUnverifiedLabel(
+    postApplyVerification,
+    appliedEvent.changedFiles
+  );
+  if (unverifiedLabel) console.log(unverifiedLabel);
+}
+function isOffScopeRepairOverrideEnabled(context) {
+  return context.allowOffScopeRepair === true || readEnv(BUILD_ALLOW_OFF_SCOPE_REPAIR).value === true;
+}
+function assertRepairArtifactAllowedForMode(winner, effectiveMode, context) {
+  const classification = winner.repairOutcome?.classification;
+  const policy = resolveRepairArtifactPolicy({
+    classification,
+    effectiveMode,
+    allowOffScopeRepair: isOffScopeRepairOverrideEnabled(context)
+  });
+  if (winner.repairOutcome) {
+    winner.repairOutcome.finalArtifactTrust = policy.finalArtifactTrust;
+  }
+  if (policy.action === "block") {
+    throw new Error(
+      `${policy.reason}. Judge verdict does not apply to the repaired final artifact. Use --allow-off-scope-repair or BUILD_ALLOW_OFF_SCOPE_REPAIR=1 to override.`
+    );
+  }
+  if (policy.action === "warn") {
+    if (classification === "off_scope") {
+      console.warn(
+        `Warning: ${policy.reason}. Judge verdict does not apply to the repaired final artifact.`
+      );
+    } else if (classification === "scope_expanded" || classification === "substantive_in_scope") {
+      console.warn(
+        `Warning: ${policy.reason}. Judge verdict only partially applies to the repaired final artifact.`
+      );
+    } else if (classification === "unknown") {
+      console.warn(`Warning: ${policy.reason}.`);
+    }
+  }
+}
+async function applyCompletionMode(winner, mode, modeSource, context) {
+  let preCreatePrDowngrade = mode === "none" ? "isolated" : mode;
+  if (mode === "auto") {
+    preCreatePrDowngrade = context.autoModePreference ?? "isolated";
+  }
+  const effectiveMode = resolveEffectiveCompletionMode(mode, {
+    ...context,
+    winner: {
+      executionMode: winner.executionMode
+    }
+  });
+  if (context.createPr === false && preCreatePrDowngrade === "pr") {
+    console.log("completion-mode=pr downgraded to isolated (--no-create-pr)");
+  }
+  if (context.createPr !== false && effectiveMode !== "pr") {
+    if (await detectRemoteConfiguration(context.projectRoot) === "none") {
+      console.log(prSkipNoRemoteNotice());
+    }
+  }
+  assertRepairArtifactAllowedForMode(winner, effectiveMode, context);
+  if ((effectiveMode === "pr" || effectiveMode === "branch") && winner.gatesPassed !== true) {
+    throw new Error(
+      `Refusing completion-mode=${effectiveMode}: apply gates did not pass for ${winner.variantId}`
+    );
+  }
+  switch (effectiveMode) {
+    case "isolated":
+      await applyIsolated(winner, context);
+      break;
+    case "pr":
+      await applyPr(winner, context);
+      break;
+    case "branch":
+      await applyBranch(winner, modeSource, context);
+      break;
+    default:
+      console.warn(
+        `Unknown completion mode: ${effectiveMode}; falling back to isolated.`
+      );
+      await applyIsolated(winner, context);
+  }
+}
+
+export {
+  assertBuildBucketWritePath,
+  persistVariantArtifact,
+  readArtifactManifest,
+  readArtifactDiff,
+  readArtifactDiffFromManifestPath,
+  readArtifactManifestFromPath,
+  listTaskArtifacts,
+  createArtifactPointer,
+  acquireCheckoutMutationLock,
+  isCiEnvironment,
+  buildRepairDiffSnapshot,
+  analyzeRepairScope,
+  resolveRepairArtifactPolicy,
+  resolveBranchApplyBoundary,
+  judgeWinnerLine,
+  assertPatchPathsAreDeliveryEligible,
+  formatPostApplyUnverifiedLabel,
+  formatApplicationVerificationLine,
+  NO_VERIFICATION_SURFACE_NOTE,
+  shouldRefusePostApplyVerification,
+  deriveBaselineFailureEvidence,
+  resolvePostApplyVerificationSurface,
+  resolvePostApplyVerificationFromOutcomes,
+  COMPETE_DIFF_BINARY_FLAGS,
+  COMPETE_GIT_APPLY_WHITESPACE_FLAGS,
+  COMPETE_DIFF_MAX_BUFFER_BYTES,
+  isRecoverableCompetitionDiff,
+  PR_REMOTE_OP_TIMEOUT_MS,
+  resolveEffectiveCompletionMode,
+  CompletionModeCancelledError,
+  applyCompletionMode
+};
+//# sourceMappingURL=chunk-SKTFRFQ7.js.map