@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-XZRS7I7W.js

@@ -0,0 +1,3673 @@
+import {
+  GitHubMergeOperationError,
+  MERGE_BATCH_BRANCH_PREFIX,
+  closeMergedBatchMembers,
+  fetchGitHubMergeObjects,
+  mergeGitHubPullRequestImmediately,
+  readGitHubMergePullRequest,
+  readGitHubMergeRepository,
+  readGitHubRequiredChecks,
+  requireCommandOk,
+  resolveGitHubMergeMethod,
+  runGitHubCli,
+  updateGitHubMergeBranch,
+  verifyGitHubMechanicalMerge
+} from "./chunk-TA3N5MMO.js";
+import {
+  claimHaltOverrideGrant,
+  followHaltOverrideGrant,
+  inheritEntrypointApproval,
+  localCiTrustForRequest,
+  recordTrustGrants
+} from "./chunk-QBWF4444.js";
+import {
+  EntrypointApprovalRequired,
+  acquireLocalCiSlot,
+  appendLandingLogEntry,
+  approvalCommand,
+  dispositionPatch,
+  keepMacAwakeForCurrentProcess,
+  queueLandingFields,
+  readGitHubCommitStatusDetail,
+  reconcileLocalCiCandidate,
+  releaseHold,
+  releaseIfApproved,
+  resolveCanonicalMainRepoRoot,
+  resolveEntrypointFingerprint,
+  resolveGitHubBranchSha,
+  resumeApprovedHolds,
+  runLocalCiWorker,
+  submitLocalCi
+} from "./chunk-G3VB2UCZ.js";
+import {
+  resolveLandingLeaseEnabled,
+  resolveMergeBatchingEnabled
+} from "./chunk-PEBWDYIW.js";
+import {
+  registerDetachedWorkerProcess,
+  signalDetachedWorkerProcess,
+  startDetachedWorkerRegistryHeartbeat,
+  unregisterDetachedWorkerProcess
+} from "./chunk-P7RVCHQV.js";
+import {
+  inspectCiIntegration
+} from "./chunk-S2XIMQJQ.js";
+import {
+  acquirePublicationTurn,
+  readPublicationTurn
+} from "./chunk-63DHNHGA.js";
+import {
+  DEFAULT_LOCAL_CI_STATUS_CONTEXT,
+  ENTRYPOINT_FINGERPRINT_PATTERN,
+  LocalCiStateStore,
+  parseLocalCiRepositoryIdentity,
+  repoStateKey
+} from "./chunk-VBENAHDA.js";
+import {
+  collectAutoFinalizeMergeEvidence,
+  collectTrailerItemIds,
+  triageTrailerItems
+} from "./chunk-AJJNW7XT.js";
+import {
+  TaskIdSchema
+} from "./chunk-AISTV5XU.js";
+import {
+  resolveGitHubRepositoryFromRemote,
+  resolveOptionalGitHubRepositoryFromRemote
+} from "./chunk-BDPYFAB4.js";
+import {
+  evaluateAutoFinalizeEligibility,
+  getBacklogExecutionProvenancePath,
+  loadBacklogExecutionProvenance
+} from "./chunk-3WY5TU2O.js";
+import {
+  atomicWriteJson
+} from "./chunk-RFDVSI4N.js";
+import {
+  acquireFencedFileLock
+} from "./chunk-QYQOVOLR.js";
+import {
+  resolveDefaultBranch
+} from "./chunk-XGU6PBO5.js";
+import {
+  buildConfigCandidates,
+  parseCanonicalBuildConfig
+} from "./chunk-FKCG7K6H.js";
+import {
+  GitExecError,
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import {
+  createLocalCiDetachedChildEnv
+} from "./chunk-SVJM3LJA.js";
+import {
+  getLocalCiStateRoot
+} from "./chunk-BV3XQQLU.js";
+import {
+  processOwnershipState,
+  readProcessIdentity
+} from "./chunk-MT2WAIR3.js";
+import {
+  DEFAULT_TIMEOUT_MS,
+  PLANNING_GIT_NETWORK_TIMEOUT_MS
+} from "./chunk-I56TH7VM.js";
+import {
+  getStateDir
+} from "./chunk-56WPYDJH.js";
+import {
+  BUILD_NIGHTLY_STATE_DIR,
+  emitCustomWarning,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/ci/merge-queue.ts
+import path8 from "path";
+import { z as z6 } from "zod";
+
+// src/core/ci/merge-queue-validation.ts
+async function validationStore(request, stateRoot) {
+  const repository = await resolveGitHubRepositoryFromRemote(request.repoRoot, "origin");
+  if (repository.toLowerCase() !== request.repository.toLowerCase()) {
+    throw new Error("Repository origin changed after merge admission.");
+  }
+  return { repository, store: new LocalCiStateStore(stateRoot ?? getLocalCiStateRoot()) };
+}
+async function acquireMergeValidationSlot(request, stateRoot, checkContinue) {
+  const { repository, store } = await validationStore(request, stateRoot);
+  return acquireLocalCiSlot({
+    repository,
+    stateRoot: store.root,
+    priority: true,
+    ...checkContinue ? { checkContinue } : {}
+  });
+}
+async function gitAtBase(repoRoot, args) {
+  const result = await execGit(args, { cwd: repoRoot });
+  if (result.exitCode !== 0) {
+    throw new Error(`git ${args[0]} failed: ${result.stderr.trim() || `exit ${result.exitCode}`}`);
+  }
+  return result.stdout;
+}
+async function resolveMergeStatusContext(request, baseSha) {
+  const [jsonc, json] = buildConfigCandidates(".build-project/config/build.config.jsonc");
+  const listing = await gitAtBase(request.repoRoot, [
+    "ls-tree",
+    "--full-tree",
+    baseSha,
+    "--",
+    jsonc,
+    json
+  ]);
+  const entries = new Map(
+    listing.split("\n").filter(Boolean).map((line) => {
+      const [meta = "", file2 = ""] = line.split("	");
+      return [file2, meta.split(" ")[2] ?? ""];
+    })
+  );
+  const file = [jsonc, json].find((candidate) => entries.has(candidate));
+  if (!file) return DEFAULT_LOCAL_CI_STATUS_CONTEXT;
+  const source = await gitAtBase(request.repoRoot, ["cat-file", "blob", entries.get(file) ?? ""]);
+  const config = parseCanonicalBuildConfig(source, `${baseSha}:${file}`);
+  if (config.status === "invalid") throw new Error("Invalid project configuration.");
+  return config.config.ci?.statusContext ?? DEFAULT_LOCAL_CI_STATUS_CONTEXT;
+}
+async function inspectMergeValidation(request, stateRoot) {
+  const { repository, store } = await validationStore(request, stateRoot);
+  try {
+    const record = await store.read(repository, request.acceptedHeadSha);
+    if (record.repository.toLowerCase() !== repository.toLowerCase() || record.sha.toLowerCase() !== request.acceptedHeadSha.toLowerCase()) {
+      throw new Error("Stored Local CI identity differs from the selected merge candidate.");
+    }
+    return record;
+  } catch (error) {
+    const cause = error instanceof Error ? error.cause : void 0;
+    if (error.code === "ENOENT" || cause?.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function reuseMergeValidation(request, baseSha, stateRoot) {
+  const existing = await inspectMergeValidation(request, stateRoot);
+  if (!existing) return void 0;
+  const { repository, store } = await validationStore(request, stateRoot);
+  return reconcileLocalCiCandidate({
+    repoRoot: request.repoRoot,
+    repository,
+    sha: request.acceptedHeadSha,
+    stateRoot: store.root,
+    expectedBaseSha: baseSha,
+    trust: localCiTrustForRequest(request)
+  });
+}
+async function validateMergeHead(request, slot, stateRoot, expectedBaseSha, signal, claimHaltOverride) {
+  const { repository, store } = await validationStore(request, stateRoot);
+  const trust = localCiTrustForRequest(request, claimHaltOverride);
+  let existing = await inspectMergeValidation(request, stateRoot);
+  if (existing && (existing.status === "succeeded" || existing.status === "succeeded_pending" || existing.status === "publication_pending")) {
+    existing = await reconcileLocalCiCandidate({
+      repoRoot: request.repoRoot,
+      repository,
+      sha: request.acceptedHeadSha,
+      stateRoot: store.root,
+      ...expectedBaseSha ? { expectedBaseSha } : {},
+      trust
+    });
+  }
+  if (existing?.status === "failed") return existing;
+  const runClaimed = async (record, runStore) => {
+    const claim = await runStore.claimWorker(record);
+    if (!claim) {
+      return { record: await runStore.read(repository, record.sha), spawned: false };
+    }
+    try {
+      const identity2 = readProcessIdentity(process.pid);
+      if (!identity2) throw new Error("Cannot establish in-process CI ownership.");
+      const assigned = await runStore.assignWorkerPid(record, process.pid, identity2);
+      if (!assigned.applied) return { record: assigned.record, spawned: false };
+      const completed = await runLocalCiWorker({
+        repository,
+        sha: record.sha,
+        stateRoot: store.root,
+        slot,
+        manageProcess: false,
+        trust,
+        signal
+      });
+      return { record: completed, spawned: false };
+    } finally {
+      await runStore.releaseWorkerClaim(repository, record.sha, process.pid, claim.generationKey).catch(() => void 0);
+    }
+  };
+  const submission = await submitLocalCi(
+    {
+      repoRoot: request.repoRoot,
+      sha: request.acceptedHeadSha,
+      branch: request.headBranch,
+      remote: "origin",
+      stateRoot: store.root,
+      trust
+    },
+    { spawnWorker: runClaimed }
+  );
+  if (submission.skipped) throw new Error(submission.reason);
+  let result = submission.record;
+  for (let recovery = 0; recovery <= 1; recovery += 1) {
+    if (result.status !== "publication_pending" && result.status !== "succeeded_pending") {
+      return result;
+    }
+    const reconciled = await reconcileLocalCiCandidate({
+      repoRoot: request.repoRoot,
+      repository,
+      sha: result.sha,
+      stateRoot: store.root,
+      trust
+    });
+    if (reconciled.status !== "queued" || reconciled.pid) return reconciled;
+    if (recovery === 1) break;
+    result = (await runClaimed(reconciled, store)).record;
+  }
+  throw new Error(
+    `Local CI revalidation remained queued after one in-process retry. Run build ci submit --sha ${request.acceptedHeadSha} from the PR branch, then hand off the merge again.`
+  );
+}
+
+// src/core/ci/merge-batch-ci-status.ts
+async function resolveLiveBatchStatusContext(input, dependencies = {}) {
+  const git = dependencies.git ?? execGit;
+  const cwd = input.repoRoot;
+  const tip = requireCommandOk(
+    await git(["ls-remote", "origin", `refs/heads/${input.branch}`], { cwd, timeoutMs: 6e4 }),
+    "Reading the target branch tip"
+  ).split(/\s+/, 1)[0];
+  if (!tip || !/^[a-f0-9]{40}$/.test(tip)) {
+    throw new Error("Could not resolve the target branch tip.");
+  }
+  requireCommandOk(
+    await git(["fetch", "--no-tags", "--no-write-fetch-head", "--refmap=", "origin", tip], {
+      cwd,
+      timeoutMs: 6e4
+    }),
+    "Fetching the target branch tip"
+  );
+  return (dependencies.resolveContext ?? resolveMergeStatusContext)({ repoRoot: cwd }, tip);
+}
+function classifyBatchMemberCiStatus(status) {
+  if (status.state === "failure" || status.state === "error") return "failed";
+  if (status.state === "pending") return "pending";
+  return "clear";
+}
+async function assertBatchMembersCiClear(input, read) {
+  const failed = [];
+  const pending = [];
+  for (const member of input.members) {
+    const label = `#${member.prNumber} at ${member.reviewedSha.slice(0, 12)}`;
+    let status;
+    try {
+      status = await read({
+        repository: input.repository,
+        sha: member.reviewedSha,
+        context: input.context
+      });
+    } catch (error) {
+      throw new Error(
+        `Batch refused: could not read the ${input.context} status of PR ${label} (${error instanceof Error ? error.message : String(error)}). Nothing was admitted; retry once GitHub is reachable.`
+      );
+    }
+    const verdict = classifyBatchMemberCiStatus(status);
+    if (verdict === "failed") {
+      const detail = [status.description, status.targetUrl].filter(Boolean).join(" ");
+      failed.push(`${label} (${status.state}${detail ? `: ${detail}` : ""})`);
+    } else if (verdict === "pending") {
+      pending.push(label);
+    }
+  }
+  if (failed.length === 0 && pending.length === 0) return;
+  const lines = ["Batch refused; nothing was admitted."];
+  if (failed.length > 0) {
+    lines.push(
+      `${input.context} failed for PR ${failed.join("; PR ")}. Fix it, or land the other members without it.`
+    );
+  }
+  if (pending.length > 0) {
+    lines.push(
+      `${input.context} is still pending for PR ${pending.join("; PR ")}. Retry once it finishes.`
+    );
+  }
+  throw new Error(lines.join(" "));
+}
+
+// src/core/ci/merge-queue-batching.ts
+var MERGE_QUEUE_BATCH_LIMIT = 4;
+var MERGE_QUEUE_BATCH_COLLECT_MS = 15e3;
+function active(request) {
+  return request.status === "queued" || request.status === "running";
+}
+function holding(batch) {
+  return batch !== void 0 && (active(batch) || batch.status === "awaiting_approval" || batch.outstandingOperation?.kind === "merge");
+}
+function queuePosition(request, requests) {
+  if (!request.batchMembers) return request.order;
+  return Math.min(
+    ...request.batchMembers.map(
+      (member) => requests.find((r) => r.id === member.requestId)?.order ?? request.order
+    )
+  );
+}
+function runnable(request, requests) {
+  return active(request) && !heldByBatch(request, requests);
+}
+function heldByBatch(request, requests) {
+  const batchId = request.batchedInto?.requestId;
+  return batchId !== void 0 && holding(requests.find((r) => r.id === batchId));
+}
+function batchable(request) {
+  return request.status === "queued" && !request.outstandingOperation && request.preparationCount === 0 && request.preparedHeads.length === 0 && request.acceptedHeadSha === request.reviewedSha && !request.batchAttempted && !request.batchedInto && !request.batchMembers && !request.headBranch.startsWith(MERGE_BATCH_BRANCH_PREFIX);
+}
+function openAt(pr, sha, targetBranch) {
+  return pr.state === "open" && !pr.draft && pr.headSha === sha && pr.baseBranch === targetBranch;
+}
+async function settleBatchMembers(store, repository, workerToken, deps) {
+  const requests = await store.list(repository);
+  const closed = /* @__PURE__ */ new Set();
+  for (const member of requests) {
+    if (!member.batchedInto || heldByBatch(member, requests)) continue;
+    const batch = requests.find((r) => r.id === member.batchedInto?.requestId);
+    const prNumber = member.batchedInto.prNumber;
+    if (batch?.status === "merged" && batch.mergeCommit) {
+      if (!active(member)) continue;
+      await store.compareAndSave(member, {
+        ...member,
+        workerToken,
+        status: "merged",
+        mergeCommit: batch.mergeCommit,
+        closeout: {
+          status: "not_applicable",
+          message: `Landed through batch #${prNumber}. This PR was closed, not merged; backlog items its commits complete are finalized by the batch closeout.`
+        }
+      });
+      continue;
+    }
+    if (batch && !closed.has(batch.id)) {
+      closed.add(batch.id);
+      await deps.closePullRequest(batch, prNumber).catch(() => void 0);
+    }
+    await store.compareAndSave(member, {
+      ...member,
+      workerToken,
+      batchedInto: void 0,
+      ...active(member) ? { lastError: `Batch #${prNumber} did not land; this PR lands on its own.` } : {}
+    });
+  }
+}
+async function selectBatchCandidates(waiting, first, deps) {
+  const candidates = [];
+  for (const request of waiting) {
+    if (candidates.length === MERGE_QUEUE_BATCH_LIMIT) break;
+    let eligible = batchable(request) && request.mergeMethod === first.mergeMethod && await deps.ownCiPassed(request) && openAt(
+      await deps.readPullRequest(request, request.prNumber),
+      request.reviewedSha,
+      request.targetBranch
+    );
+    if (eligible) {
+      try {
+        eligible = classifyBatchMemberCiStatus(await deps.readOwnCiStatus(request)) === "clear";
+      } catch {
+        return void 0;
+      }
+    }
+    if (eligible) candidates.push(request);
+    else if (request === first) return void 0;
+  }
+  return candidates;
+}
+function busy(requests) {
+  return requests.some(
+    (r) => r.status === "running" || r.outstandingOperation?.kind === "merge" || active(r) && r.batchMembers !== void 0
+  );
+}
+async function formMergeBatch(store, repository, deps) {
+  let requests = await store.list(repository);
+  if (busy(requests)) return void 0;
+  let waiting = requests.filter((r) => active(r) && !heldByBatch(r, requests));
+  let first = waiting[0];
+  if (!first || !batchable(first)) return void 0;
+  if (waiting.length < 2) {
+    if (!deps.collect || !await deps.enabled(first.repoRoot) || !await deps.ownCiPassed(first))
+      return void 0;
+    await deps.collect(first);
+    requests = await store.list(repository);
+    if (busy(requests)) return void 0;
+    waiting = requests.filter((r) => active(r) && !heldByBatch(r, requests));
+    first = waiting[0];
+    if (!first || !batchable(first) || waiting.length < 2) return void 0;
+  }
+  if (!await deps.enabled(first.repoRoot)) return void 0;
+  const candidates = await selectBatchCandidates(waiting, first, deps);
+  if (!candidates || candidates.length < 2) return void 0;
+  const members = await store.markBatchAttempt(
+    repository,
+    candidates.map((r) => r.id)
+  );
+  if (members.length < 2) return void 0;
+  let built;
+  try {
+    built = await deps.build({
+      root: first.repoRoot,
+      repository,
+      defaultBranch: first.targetBranch,
+      members: members.map((r) => ({ prNumber: r.prNumber, reviewedSha: r.reviewedSha }))
+    });
+  } catch (error) {
+    const reason = `Automatic batch not formed: ${error instanceof Error ? error.message : String(error)}`;
+    for (const member of members) {
+      await store.compareAndSave(member, { ...member, lastError: reason }).catch(() => void 0);
+    }
+    return void 0;
+  }
+  try {
+    return await store.enqueueBatch(
+      {
+        prNumber: built.batchPrNumber,
+        reviewedSha: built.batchHeadSha,
+        headBranch: built.batchBranch
+      },
+      members
+    );
+  } catch {
+    await deps.closePullRequest(first, built.batchPrNumber).catch(() => void 0);
+    return void 0;
+  }
+}
+async function assertBatchMembersUnchanged(batch, store, deps) {
+  if (!batch.batchMembers) return;
+  const pullRequests = /* @__PURE__ */ new Map();
+  for (const member of batch.batchMembers) {
+    pullRequests.set(member.prNumber, await deps.readPullRequest(batch, member.prNumber));
+  }
+  const requests = await store.list(batch.repository);
+  for (const member of batch.batchMembers) {
+    const record = requests.find((r) => r.id === member.requestId);
+    const pr = pullRequests.get(member.prNumber);
+    const unchanged = record?.status === "queued" && record.batchedInto?.requestId === batch.id && record.acceptedHeadSha === member.reviewedSha && pr !== void 0 && openAt(pr, member.reviewedSha, record.targetBranch);
+    if (!unchanged) {
+      throw new Error(
+        `Batch member #${member.prNumber} was withdrawn, superseded or changed; the batch is abandoned and its other members land on their own.`
+      );
+    }
+  }
+}
+
+// src/core/ci/merge-queue-closeout.ts
+import { readdir } from "fs/promises";
+import path from "path";
+import { execa } from "execa";
+import { z } from "zod";
+var ShaSchema = z.string().regex(/^[a-f0-9]{40}$/i);
+var PrEvidenceSchema = z.object({
+  state: z.enum(["OPEN", "CLOSED", "MERGED"]),
+  mergedAt: z.string().nullable(),
+  mergeCommit: z.object({ oid: ShaSchema }).nullable(),
+  headRefOid: ShaSchema,
+  commits: z.array(
+    z.object({
+      oid: z.string().optional(),
+      messageHeadline: z.string().optional(),
+      messageBody: z.string().optional()
+    })
+  )
+});
+function finalizeAction(input, itemId) {
+  return `build plan backlog finalize ${itemId} --pr ${input.prNumber} --commit ${input.mergeCommit}`;
+}
+function attention(input, message2, itemId) {
+  return {
+    status: "needs_attention",
+    ...itemId ? { itemId } : {},
+    message: `${message2}${itemId ? ` After resolving this, run: ${finalizeAction(input, itemId)}.` : ""}`
+  };
+}
+function closeoutEnv(input, repoRoot) {
+  return createLocalCiDetachedChildEnv({
+    GH_REPO: input.repository,
+    BUILD_PROJECT_ROOT: repoRoot,
+    BUILD_REPO: repoRoot,
+    BUILD_LOCAL_CI_WORKER: "1",
+    BUILD_CI_RECONCILING: "1"
+  });
+}
+async function runFinalizeCli(input, repoRoot, env, itemId, mergeCommit) {
+  const entry = process.argv[1];
+  if (!entry) throw new Error("Unable to resolve the current Build CLI entry path.");
+  return execa(
+    process.execPath,
+    [
+      path.resolve(entry),
+      "plan",
+      "backlog",
+      "finalize",
+      itemId,
+      "--pr",
+      String(input.prNumber),
+      "--commit",
+      mergeCommit
+    ],
+    { cwd: repoRoot, env, extendEnv: false, reject: false, timeout: DEFAULT_TIMEOUT_MS }
+  );
+}
+async function finalizeTrailerItems(input, repoRoot, satisfied = [], handled = []) {
+  const env = closeoutEnv(input, repoRoot);
+  const view = await execa(
+    "gh",
+    ["pr", "view", String(input.prNumber), "--json", "commits", "--repo", input.repository],
+    { cwd: repoRoot, env, extendEnv: false, timeout: PLANNING_GIT_NETWORK_TIMEOUT_MS }
+  );
+  const { commits } = PrEvidenceSchema.pick({ commits: true }).parse(JSON.parse(view.stdout));
+  const trailers = collectTrailerItemIds(commits);
+  const declared = trailers.declared.filter((id) => !handled.includes(id));
+  const reverted = trailers.reverted.filter((id) => !handled.includes(id));
+  const pending = declared.filter((id) => !satisfied.includes(id));
+  if (pending.length === 0 && reverted.length === 0 && satisfied.length === 0) {
+    return handled.length > 0 ? { status: "not_applicable" } : {
+      status: "not_applicable",
+      message: "No execution provenance or backlog item trailer for this PR."
+    };
+  }
+  const { eligible, skipped } = await triageTrailerItems(repoRoot, pending, {
+    prNumber: input.prNumber,
+    batchMemberPrs: input.batchMemberPrs
+  });
+  for (const itemId of reverted) {
+    skipped.push({ itemId, reason: "its trailer commit was reverted; item left pending" });
+  }
+  const finalized = [];
+  const failed = [];
+  for (const itemId of eligible) {
+    const result = await runFinalizeCli(input, repoRoot, env, itemId, input.mergeCommit);
+    if (result.exitCode === 0) {
+      finalized.push(itemId);
+      continue;
+    }
+    const detail = (result.stderr.trim() || result.stdout.trim()).split(/\r?\n/).pop();
+    failed.push(`${itemId}${detail ? ` (${detail})` : ""}; run: ${finalizeAction(input, itemId)}`);
+  }
+  const message2 = [
+    satisfied.length > 0 ? `Already finalized for this landing: ${satisfied.join(", ")}.` : "",
+    finalized.length > 0 ? `Finalized from commit trailers: ${finalized.join(", ")}.` : "",
+    failed.length > 0 ? `Finalize failed for ${failed.join("; ")}.` : "",
+    skipped.length > 0 ? `Not finalized: ${skipped.map((entry) => `${entry.itemId} (${entry.reason})`).join(", ")}.` : ""
+  ].filter(Boolean).join(" ");
+  const status = failed.length > 0 ? "needs_attention" : finalized.length + satisfied.length > 0 ? "done" : "not_applicable";
+  const everyItem = [...satisfied, ...eligible];
+  return {
+    status,
+    ...everyItem.length === 1 ? { itemId: everyItem[0] } : {},
+    ...message2 ? { message: message2 } : {}
+  };
+}
+function recordedDisposition(input, record) {
+  const itemId = record.backlogItemId;
+  const matchingCommit = record.mergeCommit?.toLowerCase() === input.mergeCommit.toLowerCase();
+  if (record.prNumber !== input.prNumber || record.mergeCommit && !matchingCommit) {
+    return attention(
+      input,
+      "Existing provenance identifies a different PR or merge commit.",
+      itemId
+    );
+  }
+  if (record.status === "archived" && matchingCommit && record.lastCompletedStep === "finalize" && !record.failedAtStep && !record.errorMessage && !record.archiveSyncWarning) {
+    return { status: "done", itemId };
+  }
+  if (record.status === "archive-sync-pending") {
+    return attention(
+      input,
+      record.archiveSyncPrNumber ? `Bookkeeping awaits archive sync PR #${record.archiveSyncPrNumber}. Merge that PR through its normal reviewed landing path.` : "Bookkeeping publication is pending without a recorded archive sync PR.",
+      itemId
+    );
+  }
+  if (record.status !== "pr-open") {
+    return attention(
+      input,
+      `Provenance status is ${record.status}; automatic finalize is ineligible.`,
+      itemId
+    );
+  }
+  return void 0;
+}
+async function associatedRecords(repoRoot, prNumber) {
+  const directory = path.dirname(getBacklogExecutionProvenancePath(repoRoot, ""));
+  if (directory !== path.join(repoRoot, ".build-project", "provenance")) {
+    throw new Error("Shared provenance root does not match the canonical repository root.");
+  }
+  let entries;
+  try {
+    entries = await readdir(directory);
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const matches = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) continue;
+    const itemId = entry.slice(0, -".json".length);
+    const record = await loadBacklogExecutionProvenance(repoRoot, itemId, {
+      cleanupTerminalLocks: false
+    });
+    if (record?.prNumber !== prNumber) continue;
+    TaskIdSchema.parse(record.backlogItemId);
+    matches.push(record);
+  }
+  return matches;
+}
+async function finalizeMergedRequest(input) {
+  let itemId;
+  try {
+    const repoRoot = await resolveCanonicalMainRepoRoot(path.resolve(input.repoRoot));
+    const repository = await resolveGitHubRepositoryFromRemote(repoRoot, "origin");
+    if (repository.toLowerCase() !== input.repository.toLowerCase()) {
+      return attention(input, "Canonical repository origin differs from the merged request.");
+    }
+    const records = await associatedRecords(repoRoot, input.prNumber);
+    const completed = records.filter(
+      (candidate) => recordedDisposition(input, candidate)?.status === "done"
+    );
+    const open2 = records.filter((candidate) => !completed.includes(candidate));
+    if (open2.length === 0) {
+      return await finalizeTrailerItems(
+        input,
+        repoRoot,
+        completed.map((candidate) => candidate.backlogItemId)
+      );
+    }
+    if (open2.length !== 1) {
+      return attention(
+        input,
+        `PR #${input.prNumber} has ambiguous execution provenance: ${open2.map((record2) => record2.backlogItemId).sort().join(", ")}. Resolve the association before finalizing.`
+      );
+    }
+    const record = open2[0];
+    itemId = record.backlogItemId;
+    const disposition = recordedDisposition(input, record);
+    if (disposition) return disposition;
+    const defaultBranch = await resolveDefaultBranch(repoRoot);
+    const fetched = await execGit(["fetch", "origin", defaultBranch], {
+      cwd: repoRoot,
+      timeoutMs: PLANNING_GIT_NETWORK_TIMEOUT_MS
+    });
+    if (fetched.exitCode !== 0) {
+      return attention(
+        input,
+        `Cannot refresh merge evidence: ${fetched.stderr || fetched.stdout}`,
+        itemId
+      );
+    }
+    const env = closeoutEnv(input, repoRoot);
+    let headSha;
+    const runEvidence = (async (command, args) => {
+      if (command === "git") {
+        const result3 = await execGit(args, { cwd: repoRoot });
+        if (result3.exitCode !== 0) throw new Error(result3.stderr || result3.stdout);
+        return result3;
+      }
+      if (command !== "gh") throw new Error(`Unexpected evidence command: ${command}`);
+      const result2 = await execa(
+        "gh",
+        args.filter((arg, index) => arg !== "--repo" && args[index - 1] !== "--repo").map(
+          (arg, index, boundArgs) => boundArgs[index - 1] === "--json" ? `${arg},headRefOid` : arg
+        ).concat("--repo", input.repository),
+        { cwd: repoRoot, env, extendEnv: false, timeout: PLANNING_GIT_NETWORK_TIMEOUT_MS }
+      );
+      const parsed = PrEvidenceSchema.parse(JSON.parse(result2.stdout));
+      headSha = parsed.headRefOid;
+      return result2;
+    });
+    const evidence = await collectAutoFinalizeMergeEvidence(
+      runEvidence,
+      repoRoot,
+      input.prNumber,
+      input.mergeCommit,
+      defaultBranch,
+      itemId
+    );
+    const eligibility = evaluateAutoFinalizeEligibility(record, input.mergeCommit, evidence);
+    if (!eligibility.eligible) return attention(input, eligibility.reason, itemId);
+    if (!headSha) return attention(input, "Unable to confirm the merged PR head.", itemId);
+    if (headSha.toLowerCase() !== input.reviewedSha.toLowerCase()) {
+      const ancestry = await execGit(["merge-base", "--is-ancestor", input.reviewedSha, headSha], {
+        cwd: repoRoot
+      });
+      if (ancestry.exitCode !== 0) {
+        return attention(
+          input,
+          "Cannot associate the reviewed SHA with the merged PR head.",
+          itemId
+        );
+      }
+    }
+    const current = await loadBacklogExecutionProvenance(repoRoot, itemId, {
+      cleanupTerminalLocks: false
+    });
+    if (!current)
+      return attention(input, "Execution provenance disappeared before finalize.", itemId);
+    const currentDisposition = recordedDisposition(input, current);
+    if (currentDisposition) return currentDisposition;
+    const result = await runFinalizeCli(input, repoRoot, env, itemId, eligibility.mergeCommit);
+    const after = await loadBacklogExecutionProvenance(repoRoot, itemId, {
+      cleanupTerminalLocks: false
+    });
+    const finalDisposition = after ? recordedDisposition(input, after) : void 0;
+    if (result.exitCode === 0 && finalDisposition?.status === "done") {
+      const extra = await finalizeTrailerItems(input, repoRoot, [], [itemId]).catch(
+        (error) => ({
+          status: "needs_attention",
+          message: `Trailer check failed: ${error instanceof Error ? error.message : String(error)}`
+        })
+      );
+      return extra.status === "needs_attention" ? { ...extra, itemId } : { ...finalDisposition, ...extra.message ? { message: extra.message } : {} };
+    }
+    if (finalDisposition?.status === "needs_attention") return finalDisposition;
+    const detail = after?.errorMessage || after?.archiveSyncWarning || result.stderr.trim() || result.stdout.trim() || "Finalization did not confirm completed archive publication.";
+    return attention(input, detail, itemId);
+  } catch (error) {
+    return attention(input, error instanceof Error ? error.message : String(error), itemId);
+  }
+}
+function finalizeMergedQueueRequest(request) {
+  return finalizeMergedRequest({
+    repoRoot: request.repoRoot,
+    repository: request.repository,
+    prNumber: request.prNumber,
+    reviewedSha: request.reviewedSha,
+    mergeCommit: request.mergeCommit,
+    batchMemberPrs: request.batchMembers?.map((member) => member.prNumber) ?? request.batchPrNumbers
+  });
+}
+
+// src/core/ci/merge-queue-lease.ts
+import { createHash } from "crypto";
+import { readFile as readFile2 } from "fs/promises";
+import path3 from "path";
+
+// src/core/ci/landing-lease.ts
+import { randomUUID } from "crypto";
+import { link, mkdir, readFile, rename, unlink, writeFile } from "fs/promises";
+import path2 from "path";
+import { z as z2 } from "zod";
+var LANDING_LEASE_SCHEMA_VERSION = 1;
+var DEFAULT_LANDING_LEASE_REF_PREFIX = "refs/build/landing/";
+var DEFAULT_LANDING_LEASE_EXPIRY_MS = 45e4;
+var DEFAULT_GIT_TIMEOUT_MS = 3e4;
+var LandingLeaseRecordSchema = z2.object({
+  schemaVersion: z2.literal(LANDING_LEASE_SCHEMA_VERSION),
+  state: z2.enum(["held", "free"]),
+  token: z2.string().min(1),
+  hostId: z2.string().min(1),
+  requestId: z2.string().min(1),
+  pr: z2.number().int().positive(),
+  head: z2.string().min(1),
+  base: z2.string().min(1),
+  /** Starts at 0 on acquire; each renewal and the release add one. */
+  generation: z2.number().int().nonnegative()
+});
+function landingLeaseRef(context) {
+  const ref = context.ref ?? `${DEFAULT_LANDING_LEASE_REF_PREFIX}${context.target}`;
+  const invalid = !/^refs\/[A-Za-z0-9._/-]+$/.test(ref) || /\.\.|\/\/|\/\.|\/$|\.$|\.lock(\/|$)/.test(ref);
+  if (invalid) throw new Error(`Invalid landing lease ref: ${ref}`);
+  return ref;
+}
+async function loadLandingHostId(filePath = path2.join(getLocalCiStateRoot(), "landing-host-id")) {
+  const read = async () => {
+    try {
+      const value = (await readFile(filePath, "utf8")).trim();
+      return z2.string().uuid().safeParse(value).success ? value : void 0;
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        return void 0;
+      }
+      throw error;
+    }
+  };
+  const existing = await read();
+  if (existing) return existing;
+  await mkdir(path2.dirname(filePath), { recursive: true, mode: 448 });
+  const created = randomUUID();
+  const temporary = `${filePath}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, `${created}
+`, { flag: "wx", mode: 384, flush: true });
+    try {
+      await link(temporary, filePath);
+      return created;
+    } catch (error) {
+      if (!(error && typeof error === "object" && "code" in error && error.code === "EEXIST")) {
+        throw error;
+      }
+    }
+    const winner = await read();
+    if (winner) return winner;
+    await rename(temporary, filePath);
+    return created;
+  } finally {
+    await unlink(temporary).catch(() => void 0);
+  }
+}
+async function runGit(context, args, input) {
+  try {
+    const result = await execGit(args, {
+      cwd: context.cwd,
+      timeoutMs: context.timeoutMs ?? DEFAULT_GIT_TIMEOUT_MS,
+      input,
+      // Never let a credential prompt or the user's pre-push hook stall or veto a lease write.
+      env: { GIT_TERMINAL_PROMPT: "0", LC_ALL: "C" }
+    });
+    if (result.exitCode === 0) return { ok: true, stdout: result.stdout };
+    return { ok: false, message: (result.stderr || result.stdout).trim().replace(/\s+/g, " ") };
+  } catch (error) {
+    const message2 = error instanceof GitExecError ? error.message : String(error);
+    return { ok: false, message: message2 };
+  }
+}
+function parseRecord(message2) {
+  let json;
+  try {
+    json = JSON.parse(message2);
+  } catch {
+    return { error: "lease commit message is not JSON" };
+  }
+  const parsed = LandingLeaseRecordSchema.safeParse(json);
+  return parsed.success ? parsed.data : { error: "lease record failed schema validation" };
+}
+async function readLandingLease(context) {
+  const ref = landingLeaseRef(context);
+  const listed = await runGit(context, ["ls-remote", "--", context.remote, ref]);
+  if (!listed.ok) return { status: "unavailable", message: listed.message };
+  const line = listed.stdout.split("\n").find((entry) => entry.endsWith(`	${ref}`));
+  if (!line) return { status: "absent" };
+  const oid = line.split("	")[0]?.trim() ?? "";
+  if (!/^[0-9a-f]{40,64}$/.test(oid)) {
+    return { status: "invalid", oid, reason: "remote advertised a malformed object id" };
+  }
+  if (!(await runGit(context, ["cat-file", "-e", `${oid}^{commit}`])).ok) {
+    const fetched = await runGit(context, [
+      "fetch",
+      "--no-tags",
+      "--no-write-fetch-head",
+      "--refmap=",
+      "--",
+      context.remote,
+      oid
+    ]);
+    if (!fetched.ok) return { status: "unavailable", message: fetched.message };
+  }
+  const raw = await runGit(context, ["cat-file", "commit", oid]);
+  if (!raw.ok) return { status: "invalid", oid, reason: raw.message };
+  const split = raw.stdout.indexOf("\n\n");
+  const record = parseRecord(split < 0 ? "" : raw.stdout.slice(split + 2).trim());
+  if ("error" in record) return { status: "invalid", oid, reason: record.error };
+  return { status: "present", oid, record };
+}
+async function stageLeaseCommit(context, record) {
+  const tree = await runGit(context, ["mktree"], "");
+  if (!tree.ok) return { status: "unavailable", message: tree.message };
+  const commit = await runGit(context, [
+    "commit-tree",
+    tree.stdout.trim(),
+    "-m",
+    JSON.stringify(record)
+  ]);
+  if (!commit.ok) return { status: "unavailable", message: commit.message };
+  return commit.stdout.trim();
+}
+async function writeLease(context, expectedOid, record) {
+  const ref = landingLeaseRef(context);
+  const staged = await stageLeaseCommit(context, record);
+  if (typeof staged !== "string") return staged;
+  const pushed = await runGit(context, [
+    "push",
+    "--no-verify",
+    `--force-with-lease=${ref}:${expectedOid ?? ""}`,
+    "--",
+    context.remote,
+    `${staged}:${ref}`
+  ]);
+  if (pushed.ok) return { status: "written", handle: { oid: staged, record } };
+  const readback = await readLandingLease(context);
+  if (readback.status === "unavailable") return readback;
+  if (readback.status === "present" && readback.record.token === record.token && readback.record.generation === record.generation && readback.record.state === record.state) {
+    return { status: "written", handle: { oid: readback.oid, record: readback.record } };
+  }
+  const observedOid = readback.status === "absent" ? void 0 : readback.oid;
+  if (observedOid !== expectedOid) return { status: "lost-race", observation: readback };
+  return { status: "unavailable", message: pushed.message };
+}
+async function acquireLandingLease(context, claim, options = {}) {
+  const observation = options.observed ?? await readLandingLease(context);
+  if (observation.status === "unavailable") return observation;
+  const acquirable = observation.status === "absent" || observation.status === "present" && observation.record.state === "free" || options.takeOver === true;
+  if (!acquirable) return { status: "held", observation };
+  const written = await writeLease(
+    context,
+    observation.status === "absent" ? void 0 : observation.oid,
+    {
+      schemaVersion: LANDING_LEASE_SCHEMA_VERSION,
+      state: "held",
+      token: randomUUID(),
+      hostId: context.hostId,
+      requestId: claim.requestId,
+      pr: claim.pr,
+      head: claim.head,
+      base: claim.base,
+      generation: 0
+    }
+  );
+  if (written.status === "written") return { status: "acquired", handle: written.handle };
+  if (written.status === "lost-race")
+    return { status: "contended", observation: written.observation };
+  return written;
+}
+async function advanceOwnedLease(context, held, state) {
+  const current = await readLandingLease(context);
+  if (current.status === "unavailable") return current;
+  if (current.status !== "present" || current.oid !== held.oid || current.record.token !== held.record.token || current.record.state !== "held") {
+    return { status: "lost-race", observation: current };
+  }
+  return await writeLease(context, current.oid, {
+    ...current.record,
+    state,
+    generation: current.record.generation + 1
+  });
+}
+async function renewLandingLease(context, held) {
+  const written = await advanceOwnedLease(context, held, "held");
+  if (written.status === "written") return { status: "renewed", handle: written.handle };
+  if (written.status === "lost-race") return { status: "lost", observation: written.observation };
+  return written;
+}
+async function releaseLandingLease(context, held) {
+  const written = await advanceOwnedLease(context, held, "free");
+  if (written.status === "written") return { status: "released", handle: written.handle };
+  if (written.status === "lost-race") return { status: "lost", observation: written.observation };
+  return written;
+}
+var LandingLeaseExpiryTracker = class {
+  expiryMs;
+  nowMs;
+  watched;
+  constructor(options = {}) {
+    this.expiryMs = options.expiryMs ?? DEFAULT_LANDING_LEASE_EXPIRY_MS;
+    this.nowMs = options.nowMs ?? (() => performance.now());
+  }
+  /** True when this commit has been seen unchanged for at least the expiry duration. */
+  observe(observation) {
+    if (observation.status === "unavailable") return false;
+    const oid = observation.status === "invalid" || observation.status === "present" && observation.record.state === "held" ? observation.oid : void 0;
+    if (oid === void 0) {
+      this.watched = void 0;
+      return false;
+    }
+    const now = this.nowMs();
+    if (this.watched?.oid !== oid) this.watched = { oid, firstSeenMs: now };
+    return now - this.watched.firstSeenMs >= this.expiryMs;
+  }
+};
+
+// src/core/ci/merge-queue-lease.ts
+var LANDING_LEASE_POLL_MS = 3e4;
+var LANDING_LEASE_BACKOFF_MS = 6e4;
+var LANDING_LEASE_RENEW_MS = 6e4;
+var LANDING_LEASE_MAX_HOLD_MS = 2 * 60 * 60 * 1e3;
+var MAX_WAIT_MS = 6 * 60 * 60 * 1e3;
+var MAX_RETRIES = 8;
+var LeaseRetry = class extends Error {
+};
+function fileReleaseMemory(file) {
+  return {
+    read: async () => {
+      try {
+        const value = JSON.parse(await readFile2(file, "utf8")).releasedAtMs;
+        return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+      } catch {
+        return void 0;
+      }
+    },
+    write: (releasedAtMs) => atomicWriteJson(file, { releasedAtMs })
+  };
+}
+function createMergeQueueLeaseDependencies(input) {
+  const target = createHash("sha256").update(input.targetBranch).digest("hex");
+  return {
+    context: async () => ({
+      cwd: input.repoRoot,
+      remote: "origin",
+      target: input.targetBranch,
+      hostId: await loadLandingHostId()
+    }),
+    releaseMemory: fileReleaseMemory(
+      path3.join(
+        input.stateRoot,
+        "landing-lease-releases",
+        repoStateKey(input.repository),
+        `${target}.json`
+      )
+    )
+  };
+}
+function defaultLog(message2) {
+  emitCustomWarning("INFO" /* INFO */, "configuration" /* CONFIGURATION */, message2, {
+    subsystem: "ci/merge-queue-lease",
+    executionPhase: "execution"
+  });
+}
+var RequestLandingLease = class {
+  constructor(deps, env) {
+    this.deps = deps;
+    this.env = env;
+    this.inactive = deps === void 0;
+    this.ops = {
+      read: readLandingLease,
+      acquire: acquireLandingLease,
+      renew: renewLandingLease,
+      release: releaseLandingLease,
+      ...deps?.ops
+    };
+  }
+  deps;
+  env;
+  ops;
+  context;
+  handle;
+  heldSinceMs = 0;
+  renewedAtMs = 0;
+  renewing;
+  lost = false;
+  lostController = new AbortController();
+  /** A held lease this request may replace: its own earlier lease, or an expired one. */
+  replaceable;
+  retries = 0;
+  inactive;
+  note;
+  /** Shown in `build ci status` when the lease could not be used for this request. */
+  statusNote() {
+    return this.note;
+  }
+  /** The gate's signal plus this lease's loss: a lost lease stops the gate like moved main. */
+  withSignal(signal) {
+    return AbortSignal.any([signal, this.lostController.signal]);
+  }
+  /**
+   * Wait until the lease is free, expired, or this request's own, holding neither capacity nor
+   * the turn. Returns early (fail open) when the lease is unavailable or the wait is exhausted.
+   */
+  async wait(input) {
+    if (this.inactive || !this.deps) return;
+    try {
+      this.context ??= await this.deps.context();
+    } catch (error) {
+      this.markUnavailable(`no host identity: ${describe(error)}`);
+      return;
+    }
+    const context = this.context;
+    const tracker = new LandingLeaseExpiryTracker({
+      expiryMs: this.deps.expiryMs,
+      nowMs: this.env.nowMs
+    });
+    const deadline = this.env.nowMs() + (this.deps.maxWaitMs ?? MAX_WAIT_MS);
+    let announced;
+    this.replaceable = void 0;
+    const backoffUntilMs = this.env.nowMs() + await this.backoffRemainingMs();
+    for (; ; ) {
+      await input.checkContinue();
+      const seen = await this.ops.read(context);
+      if (seen.status === "unavailable") {
+        this.markUnavailable(seen.message);
+        return;
+      }
+      const expired = tracker.observe(seen);
+      const held = seen.status === "present" && seen.record.state === "held" ? seen.record : void 0;
+      if (!held && seen.status !== "invalid") {
+        const pause = backoffUntilMs - this.env.nowMs();
+        if (pause <= 0 || seen.status === "present" && seen.record.hostId !== context.hostId) {
+          return;
+        }
+        await this.env.pause(pause);
+        continue;
+      }
+      if (held?.hostId === context.hostId && held.requestId === this.env.requestId || expired) {
+        this.replaceable = seen;
+        return;
+      }
+      const text = held ? `Waiting for another host (lease): host ${held.hostId.slice(0, 8)} is landing PR #${held.pr}.` : "Waiting for another host (lease): the lease record is unreadable; waiting for it to expire.";
+      if (text !== announced) {
+        announced = text;
+        await input.announce(text);
+      }
+      if (this.env.nowMs() >= deadline) {
+        this.markUnavailable("waited too long for the lease");
+        return;
+      }
+      await this.env.pause(this.deps.pollMs ?? LANDING_LEASE_POLL_MS);
+    }
+  }
+  /** Take the lease after capacity is held. Throws {@link LeaseRetry} when another host won. */
+  async acquire(baseSha) {
+    if (this.inactive || !this.context) return;
+    const replaceable = this.replaceable;
+    this.replaceable = void 0;
+    let result;
+    try {
+      result = await this.ops.acquire(
+        this.context,
+        this.env.claim(baseSha),
+        replaceable ? { observed: replaceable, takeOver: true } : {}
+      );
+    } catch (error) {
+      result = { status: "unavailable", message: describe(error) };
+    }
+    if (result.status === "acquired") {
+      this.handle = result.handle;
+      this.heldSinceMs = this.renewedAtMs = this.env.nowMs();
+      this.lost = false;
+    } else if (result.status === "unavailable") {
+      this.markUnavailable(result.message);
+    } else {
+      this.requeue("another host took the lease first");
+    }
+  }
+  /**
+   * Renew a held lease. `force` is the watcher tick; otherwise at most once per interval, so the
+   * processor's guard keeps a long prepare or wait alive without a second timer. Never throws:
+   * `lost` stops the current round, an unreachable remote is retried on the next call.
+   */
+  async renew(force = false) {
+    if (!this.handle || this.lost) return;
+    if (!force && this.env.nowMs() - this.renewedAtMs < (this.deps?.renewMs ?? LANDING_LEASE_RENEW_MS)) {
+      return;
+    }
+    this.renewing ??= this.renewOnce().finally(() => {
+      this.renewing = void 0;
+    });
+    await this.renewing;
+  }
+  async renewOnce() {
+    const held = this.handle;
+    if (!held || !this.context) return;
+    try {
+      const result = await this.ops.renew(this.context, held);
+      if (result.status === "renewed") {
+        this.handle = result.handle;
+        this.renewedAtMs = this.env.nowMs();
+      } else if (result.status === "lost") {
+        this.lost = true;
+        this.lostController.abort(
+          new Error("The cross-host landing lease was taken over; waiting for it again.")
+        );
+      }
+    } catch {
+    }
+  }
+  /**
+   * `round`: before starting a round, stop if the lease was lost or held past the maximum.
+   * `merge`: renew now and stop if the lease was lost, so no merge follows a lost lease that
+   * could be detected. Never called after a merge was dispatched.
+   */
+  async checkpoint(point) {
+    if (!this.handle) return;
+    if (point === "merge") await this.renew(true);
+    this.throwIfLost();
+    if (point === "round" && this.env.nowMs() - this.heldSinceMs >= this.holdLimitMs()) {
+      this.requeue("held the lease for the maximum time");
+    }
+  }
+  throwIfLost() {
+    if (this.lost) this.requeue("the lease was taken over");
+  }
+  /** Best-effort; never throws, so it cannot mask the request's real outcome. */
+  async release() {
+    await this.renewing;
+    const held = this.handle;
+    this.handle = void 0;
+    this.lost = false;
+    this.lostController = new AbortController();
+    if (!held || !this.context) return;
+    try {
+      const result = await this.ops.release(this.context, held);
+      if (result.status === "released") {
+        await this.deps?.releaseMemory?.write((this.deps.wallNowMs ?? Date.now)());
+      }
+    } catch {
+    }
+  }
+  holdLimitMs() {
+    return this.deps?.maxHoldMs ?? LANDING_LEASE_MAX_HOLD_MS;
+  }
+  /** Count a re-queue; past the cap the request stops using the lease instead of looping. */
+  requeue(reason) {
+    this.retries += 1;
+    if (this.retries > MAX_RETRIES) {
+      this.markUnavailable("too many lease re-queues");
+      return;
+    }
+    throw new LeaseRetry(`Landing lease: ${reason}.`);
+  }
+  /** Back-off left since this host's last release, read once when a wait starts. */
+  async backoffRemainingMs() {
+    const backoffMs = this.deps?.backoffMs ?? LANDING_LEASE_BACKOFF_MS;
+    try {
+      const released = await this.deps?.releaseMemory?.read();
+      if (released === void 0) return 0;
+      const elapsed = (this.deps?.wallNowMs ?? Date.now)() - released;
+      return Math.min(backoffMs, Math.max(0, backoffMs - elapsed));
+    } catch {
+      return 0;
+    }
+  }
+  markUnavailable(detail) {
+    this.inactive = true;
+    if (this.note) return;
+    const scrubbed = detail.replace(/\/\/[^/@\s]+@/g, "//").slice(0, 200);
+    this.note = "Landing lease unavailable; landing without cross-host coordination.";
+    (this.deps?.log ?? defaultLog)(`${this.note} (${scrubbed})`);
+  }
+};
+function describe(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/core/ci/merge-queue-processor.ts
+import { setTimeout as delay } from "timers/promises";
+
+// src/core/ci/main-watcher.ts
+var DEFAULT_MAIN_WATCH_INTERVAL_MS = 6e4;
+var LS_REMOTE_TIMEOUT_MS = 2e4;
+var SHA_PATTERN = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i;
+var MainReadError = class extends Error {
+  constructor(message2) {
+    super(message2);
+    this.name = "MainReadError";
+  }
+};
+var MainMovedError = class extends Error {
+  constructor(fromSha, toSha) {
+    super(`Target branch moved from ${fromSha.slice(0, 12)} to ${toSha.slice(0, 12)}.`);
+    this.fromSha = fromSha;
+    this.toSha = toSha;
+    this.name = "MainMovedError";
+  }
+  fromSha;
+  toSha;
+};
+function normalizeSha(value, source) {
+  const sha = value.trim();
+  if (!SHA_PATTERN.test(sha)) throw new MainReadError(`${source} returned a malformed SHA.`);
+  return sha.toLowerCase();
+}
+async function readRemoteBranchTip(input) {
+  const ref = `refs/heads/${input.branch}`;
+  const result = await execGit(["ls-remote", input.remote ?? "origin", ref], {
+    cwd: input.repoRoot,
+    timeoutMs: input.timeoutMs ?? LS_REMOTE_TIMEOUT_MS,
+    env: { GIT_TERMINAL_PROMPT: "0" }
+  });
+  if (result.exitCode !== 0) {
+    throw new MainReadError(`git ls-remote failed: ${result.stderr.trim() || result.exitCode}`);
+  }
+  const lines = result.stdout.split("\n").map((line) => line.trim().split(/\s+/)).filter((fields) => fields.length === 2 && fields[1] === ref);
+  if (lines.length !== 1) {
+    throw new MainReadError(`git ls-remote did not return exactly one ${ref}.`);
+  }
+  return normalizeSha(lines[0]?.[0] ?? "", "git ls-remote");
+}
+var MainWatcher = class {
+  constructor(options) {
+    this.options = options;
+    this.baseSha = options.baseSha.toLowerCase();
+  }
+  options;
+  controller = new AbortController();
+  baseSha;
+  timer;
+  stopped = false;
+  movedToSha;
+  failures = 0;
+  failure;
+  /** Aborts, with a {@link MainMovedError} reason, once movement is confirmed. */
+  get signal() {
+    return this.controller.signal;
+  }
+  get moved() {
+    return this.movedToSha !== void 0;
+  }
+  get errorCount() {
+    return this.failures;
+  }
+  get lastError() {
+    return this.failure;
+  }
+  throwIfMoved() {
+    if (this.movedToSha !== void 0) throw new MainMovedError(this.baseSha, this.movedToSha);
+  }
+  start() {
+    if (!this.stopped && !this.timer) this.schedule();
+    return this;
+  }
+  /** After stop() this watcher can never abort anything, even from an in-flight read. */
+  stop() {
+    this.stopped = true;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = void 0;
+  }
+  /** One check. Exposed so callers and tests can drive it without the timer. */
+  async tick() {
+    if (this.moved) return "moved";
+    let confirmed;
+    try {
+      const tip = normalizeSha(await this.options.readTip(), "Branch tip read");
+      if (tip === this.baseSha) return "unchanged";
+      confirmed = normalizeSha(await this.options.confirmBase(), "Base read");
+    } catch (error) {
+      this.failures += 1;
+      this.failure = error;
+      return "error";
+    }
+    if (confirmed === this.baseSha) return "unchanged";
+    if (this.stopped) return "unchanged";
+    this.movedToSha = confirmed;
+    this.controller.abort(new MainMovedError(this.baseSha, confirmed));
+    return "moved";
+  }
+  schedule() {
+    const timer = setTimeout(async () => {
+      this.timer = void 0;
+      await this.tick();
+      try {
+        if (!this.stopped) await this.options.onTick?.();
+      } catch {
+      }
+      if (!this.stopped && !this.moved) this.schedule();
+    }, this.options.intervalMs ?? DEFAULT_MAIN_WATCH_INTERVAL_MS);
+    timer.unref?.();
+    this.timer = timer;
+  }
+};
+
+// src/core/ci/merge-queue-processor-helpers.ts
+var RequestChanged = class extends Error {
+};
+var BaseMoved = class extends Error {
+};
+var CapacityRequired = class extends Error {
+};
+var ForeignCiRace = class extends Error {
+  constructor(record) {
+    super("Foreign CI acquired the candidate while merge preparation was admitting it.");
+    this.record = record;
+  }
+  record;
+};
+function active2(request) {
+  return request.status === "queued" || request.status === "running";
+}
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function sameRepository(left, right) {
+  return left?.toLowerCase() === right.toLowerCase();
+}
+function busy2(record, headSha) {
+  return record?.sha === headSha && (record.status === "queued" || record.status === "running");
+}
+function refusedForMovedBase(detail) {
+  return /base branch (?:was )?modified|not up to date|out of date with (?:the )?base/i.test(
+    detail
+  );
+}
+function attestationPending(record) {
+  return record.status === "publication_pending" || record.status === "succeeded_pending";
+}
+async function isAncestor(input) {
+  const result = await execGit(["merge-base", "--is-ancestor", input.ancestorSha, input.headSha], {
+    cwd: input.repoRoot,
+    timeoutMs: 6e4,
+    env: { GIT_NO_REPLACE_OBJECTS: "1" }
+  });
+  if (result.exitCode === 0) return true;
+  if (result.exitCode === 1) return false;
+  throw new Error(`Unable to inspect PR ancestry: ${result.stderr || result.stdout}`);
+}
+function onlyTrustChanged(before, after) {
+  if (after.version <= before.version) return false;
+  const ignored = /* @__PURE__ */ new Set(["version", "updatedAt", "trustGrants"]);
+  const keys = /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)]);
+  return [...keys].every(
+    (key) => ignored.has(key) || JSON.stringify(before[key]) === JSON.stringify(after[key])
+  );
+}
+function assertPrIdentity(request, pr) {
+  if (!sameRepository(pr.repository, request.repository) || pr.prNumber !== request.prNumber || pr.baseBranch !== request.targetBranch || !sameRepository(pr.headRepository, request.repository) || pr.headBranch !== request.headBranch) {
+    throw new Error("PR identity, head repository or target changed after admission.");
+  }
+}
+function assertPrAdmitted(request, pr) {
+  assertPrIdentity(request, pr);
+  if (pr.state !== "open" || pr.draft || pr.autoMergeEnabled) {
+    throw new Error("PR is closed, draft or independently armed for native auto-merge.");
+  }
+  if (pr.headSha !== request.acceptedHeadSha) {
+    throw new Error("PR author head changed from the accepted reviewed lineage.");
+  }
+}
+function cachedProofMatches(request, record, baseSha) {
+  return record?.status === "succeeded" && sameRepository(record.repository, request.repository) && record.sha === request.acceptedHeadSha && record.trustedBaseSha === baseSha && record.trustedBaseRef === request.targetBranch && !record.entrypointApprovalPending && !record.outstandingRemoteStatusPublication;
+}
+async function ownerStateOf(record, override) {
+  if (override) return override(record);
+  if (!record.pid) return "unknown";
+  return processOwnershipState(
+    record.pid,
+    record.pidIdentity,
+    record.startedAt ?? record.updatedAt
+  );
+}
+function classifyMergeReadback(pr, operation, request, late) {
+  const sameRequest = pr !== void 0 && sameRepository(pr.repository, request.repository) && pr.prNumber === request.prNumber;
+  if (pr && (pr.state === "merged" || pr.state === "closed")) {
+    if (!sameRequest) {
+      throw new Error("Terminal PR readback does not identify this merge request.");
+    }
+    if (pr.state === "merged" && pr.headSha === operation.expectedHeadSha && pr.baseBranch === request.targetBranch && pr.mergeCommit) {
+      return { kind: "merged", mergeCommit: pr.mergeCommit };
+    }
+    const detail = pr.state === "closed" ? "PR was closed without a confirmed merge; publication is no longer blocked." : pr.headSha !== operation.expectedHeadSha || pr.baseBranch !== request.targetBranch ? "PR was merged at another head or target; this request did not confirm its reviewed merge." : "PR is merged but its merge commit could not be confirmed.";
+    return { kind: "stop", detail };
+  }
+  if (pr?.state === "open" && sameRequest && pr.headSha !== operation.expectedHeadSha) {
+    return {
+      kind: "stop",
+      detail: "PR head moved before the reviewed merge was confirmed; it did not merge."
+    };
+  }
+  if (late && pr?.state === "open" && sameRequest && pr.headSha === operation.expectedHeadSha) {
+    return {
+      kind: "stop",
+      detail: "GitHub still shows the PR open at the reviewed head ten minutes after the merge request; it did not merge."
+    };
+  }
+  return { kind: "wait" };
+}
+
+// src/core/ci/merge-queue-processor.ts
+var MAX_PREPARATIONS = 2;
+var POLL_DELAY_MS = 2e3;
+var MAX_SETTLEMENT_CAS_ATTEMPTS = 2;
+var CI_WAIT_TIMEOUT_MS = 6 * 60 * 60 * 1e3;
+var CONTROL_PLANE_TIMEOUT_MS = 10 * 60 * 1e3;
+var MAX_FOREIGN_CI_RETRIES = 1;
+var MAX_CAPACITY_FALLBACKS = 1;
+async function processMergeRequest(input, dependencies) {
+  if (!input.request.workerToken) {
+    throw new Error("A merge processor request requires the current coordinator workerToken.");
+  }
+  return new RequestProcessor(input, dependencies).run();
+}
+var RequestProcessor = class {
+  constructor(input, deps) {
+    this.input = input;
+    this.deps = deps;
+    this.current = input.request;
+    this.token = input.request.workerToken;
+    this.ciWaitDeadline = this.tick() + CI_WAIT_TIMEOUT_MS;
+    this.lease = new RequestLandingLease(deps.landingLease, {
+      requestId: input.request.id,
+      nowMs: () => this.tick(),
+      pause: (milliseconds) => this.pauseFor(milliseconds),
+      claim: (base) => ({
+        requestId: this.current.id,
+        pr: this.current.prNumber,
+        head: this.current.acceptedHeadSha,
+        base
+      })
+    });
+  }
+  input;
+  deps;
+  current;
+  token;
+  slot;
+  turn;
+  ciWaitDeadline;
+  forceCapacity = false;
+  watcher;
+  lease;
+  get target() {
+    return {
+      repository: this.current.repository,
+      targetBranch: this.current.targetBranch,
+      stateRoot: this.input.stateRoot ?? this.input.store.root
+    };
+  }
+  get prInput() {
+    const { repoRoot, repository, prNumber } = this.current;
+    return { repoRoot, repository, prNumber };
+  }
+  async fresh() {
+    const fresh = await this.input.store.read(this.current.repository, this.current.id);
+    if (!fresh) throw new RequestChanged("Merge request no longer exists.");
+    this.current = fresh;
+    if (fresh.workerToken !== this.token) {
+      throw new RequestChanged("Merge request coordinator ownership changed.");
+    }
+    return fresh;
+  }
+  /** Last awaited check immediately before each new remote write. */
+  async guard(requireActive = true) {
+    this.deps.signal?.throwIfAborted();
+    if (this.watcher?.moved) throw new BaseMoved();
+    await this.deps.assertCoordinatorOwned?.();
+    await this.turn?.assertOwned();
+    await this.lease.renew();
+    const before = this.current;
+    const fresh = await this.fresh();
+    if (fresh.version !== before.version && !onlyTrustChanged(before, fresh) || requireActive && !active2(fresh)) {
+      throw new RequestChanged("Merge request changed or was withdrawn.");
+    }
+  }
+  async save(patch) {
+    for (let attempt = 0; ; attempt += 1) {
+      const before = this.current;
+      const result = await this.input.store.compareAndSave(before, {
+        ...before,
+        ...patch,
+        workerToken: this.token,
+        updatedAt: (this.deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString()
+      });
+      this.current = result.record;
+      if (result.applied) return;
+      if (attempt > 0 || patch.trustGrants || !onlyTrustChanged(before, result.record)) {
+        throw new RequestChanged("Merge request CAS changed.");
+      }
+    }
+  }
+  /**
+   * Readback may settle an in-flight operation after cancellation. Retry only
+   * this narrow CAS, at most once, retaining a stopped status unless merged.
+   */
+  async settle(operation, patch) {
+    for (let attempt = 0; attempt < MAX_SETTLEMENT_CAS_ATTEMPTS; attempt += 1) {
+      await this.deps.assertCoordinatorOwned?.();
+      await this.turn?.assertOwned();
+      await this.fresh();
+      const outstanding = this.current.outstandingOperation;
+      if (outstanding?.kind !== operation.kind || outstanding.expectedHeadSha !== operation.expectedHeadSha || outstanding.requestedAt !== operation.requestedAt) {
+        throw new RequestChanged("Outstanding merge operation changed.");
+      }
+      const grants = patch.acceptedHeadSha ? await followHaltOverrideGrant(
+        this.current,
+        patch.acceptedHeadSha,
+        () => this.deps.inspectValidation?.(this.validationInput(operation.baseSha ?? ""))
+      ) : void 0;
+      try {
+        await this.save({
+          ...patch,
+          ...grants ? { trustGrants: grants } : {},
+          status: patch.status === "merged" ? "merged" : active2(this.current) ? patch.status ?? this.current.status : this.current.status,
+          outstandingOperation: void 0
+        });
+        return;
+      } catch (error) {
+        if (!(error instanceof RequestChanged)) throw error;
+        if (attempt + 1 === MAX_SETTLEMENT_CAS_ATTEMPTS) throw error;
+      }
+    }
+  }
+  /** Stop the request: held for an entrypoint approval, or needing attention. */
+  async disposition(error) {
+    await this.fresh();
+    await this.save(dispositionPatch(this.current, error, this.deps.now?.() ?? /* @__PURE__ */ new Date()));
+  }
+  /** Spend the request's recorded halt override durably before any run exists. */
+  async claimHaltOverride() {
+    await this.guard();
+    const claim = claimHaltOverrideGrant(this.current, this.deps.now?.() ?? /* @__PURE__ */ new Date());
+    if (claim.grants) await this.save({ trustGrants: claim.grants });
+    return claim.covered;
+  }
+  tick() {
+    return this.deps.monotonicNow?.() ?? performance.now();
+  }
+  async waitUntil(deadline) {
+    await this.pauseFor(Math.min(POLL_DELAY_MS, Math.max(0, deadline - this.tick())));
+  }
+  async pauseFor(milliseconds) {
+    this.deps.signal?.throwIfAborted();
+    if (this.deps.pause) await this.deps.pause(milliseconds);
+    else await delay(milliseconds, void 0, { signal: this.deps.signal });
+  }
+  async readPr() {
+    return (this.deps.readPullRequest ?? readGitHubMergePullRequest)(this.prInput);
+  }
+  assertAdmitted(pr) {
+    assertPrAdmitted(this.current, pr);
+  }
+  async checkRepository() {
+    const repository = await (this.deps.readRepository ?? readGitHubMergeRepository)({
+      repoRoot: this.current.repoRoot,
+      repository: this.current.repository
+    });
+    if (!sameRepository(repository.repository, this.current.repository) || repository.defaultBranch !== this.current.targetBranch || !repository.allowedMergeMethods.includes(this.current.mergeMethod)) {
+      throw new Error("Repository default target or allowed merge method changed.");
+    }
+  }
+  async base() {
+    return (this.deps.readBaseSha ?? resolveGitHubBranchSha)({
+      repository: this.current.repository,
+      branch: this.current.targetBranch
+    });
+  }
+  async fetch(headSha, baseSha) {
+    await (this.deps.fetchObjects ?? fetchGitHubMergeObjects)({
+      ...this.prInput,
+      headSha,
+      baseSha,
+      baseBranch: this.current.targetBranch
+    });
+  }
+  async headOnBase(baseSha) {
+    await this.fetch(this.current.acceptedHeadSha, baseSha);
+    return (this.deps.isAncestor ?? isAncestor)({
+      repoRoot: this.current.repoRoot,
+      ancestorSha: baseSha,
+      headSha: this.current.acceptedHeadSha
+    });
+  }
+  async verify(head) {
+    await this.fetch(head.sha, head.baseSha);
+    const verification = await (this.deps.verifyMechanicalMerge ?? verifyGitHubMechanicalMerge)({
+      repoRoot: this.current.repoRoot,
+      preparedSha: head.sha,
+      parentSha: head.parentSha,
+      baseSha: head.baseSha
+    });
+    if (!verification.verified) {
+      throw new Error(
+        `Prepared head is not the reviewed mechanical merge: ${verification.reason}.`
+      );
+    }
+  }
+  async verifyOriginalLineage() {
+    if (this.current.preparedHeads.length > MAX_PREPARATIONS || this.current.preparedHeads.length > this.current.preparationCount) {
+      throw new Error("Invalid recorded preparation budget or lineage.");
+    }
+    let parent = this.current.reviewedSha;
+    for (const head of this.current.preparedHeads) {
+      if (head.parentSha !== parent)
+        throw new Error("Prepared lineage does not start at the reviewed head.");
+      await this.verify(head);
+      parent = head.sha;
+    }
+    if (parent !== this.current.acceptedHeadSha) {
+      throw new Error("Accepted head does not match the original reviewed preparation lineage.");
+    }
+    const operation = this.current.outstandingOperation;
+    if (operation && operation.expectedHeadSha !== parent) {
+      throw new Error("Outstanding operation does not match the accepted preparation lineage.");
+    }
+  }
+  validationInput(baseSha) {
+    return { request: this.current, headSha: this.current.acceptedHeadSha, baseSha };
+  }
+  /**
+   * Watch the target branch while `run` depends on `baseSha`. Guarded waits see
+   * movement as BaseMoved; a gate the queue runs itself is aborted through the
+   * watcher's signal. The watcher is stopped before returning, so it can never
+   * abort later work.
+   */
+  async watching(baseSha, run) {
+    const watcher = new MainWatcher({
+      baseSha,
+      intervalMs: this.deps.mainWatch?.intervalMs,
+      readTip: () => (this.deps.mainWatch?.readTip ?? readRemoteBranchTip)({
+        repoRoot: this.current.repoRoot,
+        branch: this.current.targetBranch
+      }),
+      confirmBase: () => this.base(),
+      onTick: () => this.lease.renew(true)
+    }).start();
+    this.watcher = watcher;
+    try {
+      return await run(watcher);
+    } finally {
+      watcher.stop();
+      this.watcher = void 0;
+    }
+  }
+  /**
+   * Another process's run is not ours to stop: no run-bound cancel exists for it,
+   * so on movement this only stops waiting and lets the request prepare against
+   * the new base (that run's head can no longer become landing evidence).
+   */
+  async awaitExistingCi(baseSha, observed) {
+    try {
+      await this.watching(baseSha, () => this.waitForExistingCi(baseSha, observed));
+    } catch (error) {
+      if (!(error instanceof BaseMoved)) throw error;
+    }
+  }
+  /** Holds neither capacity nor publication while the existing CI owner progresses. */
+  async waitForExistingCi(baseSha, observed) {
+    await this.guard();
+    let record = observed ?? await this.deps.inspectValidation?.(this.validationInput(baseSha));
+    while (record && busy2(record, this.current.acceptedHeadSha)) {
+      await this.guard();
+      if (await ownerStateOf(record, this.deps.validationOwnerState) === "reclaimable") return;
+      if (!this.deps.inspectValidation) {
+        throw new Error("Active CI cannot be awaited without an inspectValidation boundary.");
+      }
+      if (this.tick() >= this.ciWaitDeadline) {
+        throw new Error(
+          "Existing Local CI wait expired after the six-hour capacity-compatible bound."
+        );
+      }
+      await this.waitUntil(this.ciWaitDeadline);
+      await this.guard();
+      record = await this.deps.inspectValidation(this.validationInput(baseSha));
+    }
+  }
+  async checkForeignCi(baseSha) {
+    const record = await this.deps.inspectValidation?.(this.validationInput(baseSha));
+    if (record && busy2(record, this.current.acceptedHeadSha) && await ownerStateOf(record, this.deps.validationOwnerState) !== "reclaimable") {
+      throw new ForeignCiRace(record);
+    }
+  }
+  async waitForAttestation(record, validationInput) {
+    if (!attestationPending(record) || record.entrypointApprovalPending) return record;
+    const deadline = this.tick() + CONTROL_PLANE_TIMEOUT_MS;
+    if (this.deps.reconcileValidation) {
+      await this.guard();
+      record = await this.deps.reconcileValidation(validationInput);
+    }
+    while (attestationPending(record) && !record.entrypointApprovalPending) {
+      await this.guard();
+      if (this.tick() >= deadline) {
+        throw new Error(
+          "Candidate attestation remains pending after the ten-minute control-plane deadline."
+        );
+      }
+      await this.waitUntil(deadline);
+      await this.guard();
+      record = await this.deps.inspectValidation?.(validationInput) ?? record;
+    }
+    return record;
+  }
+  async reconcileUpdate(operation) {
+    if (!operation.baseSha) throw new Error("Recorded update has no identified base.");
+    let lastError = "GitHub update result is still unresolved.";
+    const deadline = this.tick() + CONTROL_PLANE_TIMEOUT_MS;
+    for (; ; ) {
+      await this.guard(false);
+      let pr;
+      try {
+        pr = await this.readPr();
+      } catch (error) {
+        lastError = message(error);
+      }
+      if (pr) {
+        assertPrIdentity(this.current, pr);
+        if (pr.headSha !== operation.expectedHeadSha) {
+          const prepared = {
+            sha: pr.headSha,
+            parentSha: operation.expectedHeadSha,
+            baseSha: operation.baseSha
+          };
+          await this.verify(prepared);
+          await this.settle(operation, {
+            acceptedHeadSha: pr.headSha,
+            preparedHeads: [...this.current.preparedHeads, prepared],
+            lastError: void 0
+          });
+          return;
+        }
+      }
+      if (this.tick() >= deadline) break;
+      await this.waitUntil(deadline);
+    }
+    throw new Error(`Update outcome unresolved after bounded readback: ${lastError}`);
+  }
+  async prepare(baseSha) {
+    if (this.current.preparationCount >= MAX_PREPARATIONS) {
+      throw new Error(
+        "Automatic preparation limit (2) exhausted; fresh reviewed authorization is required."
+      );
+    }
+    await this.guard();
+    const operation = {
+      kind: "update",
+      expectedHeadSha: this.current.acceptedHeadSha,
+      baseSha,
+      requestedAt: (this.deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.save({
+      preparationCount: this.current.preparationCount + 1,
+      outstandingOperation: operation
+    });
+    let dispatched = false;
+    try {
+      await this.guard();
+      dispatched = true;
+      await (this.deps.updateBranch ?? updateGitHubMergeBranch)({
+        ...this.prInput,
+        expectedHeadSha: operation.expectedHeadSha
+      });
+    } catch (error) {
+      if (!dispatched || error instanceof GitHubMergeOperationError && error.outcome === "rejected") {
+        await this.settle(operation, {});
+        throw error;
+      }
+    }
+    await this.reconcileUpdate(operation);
+  }
+  async clearMergeRecovery(operation) {
+    await this.deps.assertCoordinatorOwned?.();
+    await this.fresh();
+    const outstanding = this.current.outstandingOperation;
+    if (outstanding?.kind !== "merge" || outstanding.expectedHeadSha !== operation.expectedHeadSha || outstanding.requestedAt !== operation.requestedAt) {
+      throw new RequestChanged("Outstanding merge operation changed before clearing recovery.");
+    }
+    await this.turn.clearRecovery();
+  }
+  async confirmMerged(operation, mergeCommit) {
+    await this.clearMergeRecovery(operation);
+    await this.settle(operation, { status: "merged", mergeCommit, lastError: void 0 });
+  }
+  async reconcileMerge(operation) {
+    let lastError = "PR is not yet observed merged.";
+    const remaining = Date.parse(operation.requestedAt) + CONTROL_PLANE_TIMEOUT_MS - (this.deps.now?.() ?? /* @__PURE__ */ new Date()).getTime();
+    const deadline = this.tick() + Math.max(0, remaining);
+    for (; ; ) {
+      const late = this.tick() >= deadline;
+      await this.guard(false);
+      let pr;
+      try {
+        pr = await this.readPr();
+      } catch (error) {
+        lastError = message(error);
+      }
+      const outcome = classifyMergeReadback(pr, operation, this.current, late);
+      if (outcome.kind === "merged") {
+        await this.confirmMerged(operation, outcome.mergeCommit);
+        return;
+      }
+      if (outcome.kind === "stop") {
+        await this.clearMergeRecovery(operation);
+        await this.settle(operation, { status: "needs_attention", lastError: outcome.detail });
+        return;
+      }
+      if (late) break;
+      await this.waitUntil(deadline);
+    }
+    throw new Error(`Merge outcome unresolved after bounded readback: ${lastError}`);
+  }
+  /** Resolves 'base-moved' when GitHub refused the merge because the target moved. */
+  async merge(baseSha) {
+    const operation = {
+      kind: "merge",
+      expectedHeadSha: this.current.acceptedHeadSha,
+      baseSha,
+      requestedAt: (this.deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.guard();
+    await this.save({ outstandingOperation: operation });
+    let dispatched = false;
+    try {
+      await this.turn.requireRecovery(
+        `PR #${this.current.prNumber} merge outcome may be unresolved.`
+      );
+      await this.guard();
+      dispatched = true;
+      const response = await (this.deps.merge ?? mergeGitHubPullRequestImmediately)({
+        ...this.prInput,
+        expectedHeadSha: operation.expectedHeadSha,
+        method: this.current.mergeMethod
+      });
+      if (response.merged) {
+        await this.confirmMerged(operation, response.mergeCommit);
+        return "done";
+      }
+      await this.clearMergeRecovery(operation);
+      if (refusedForMovedBase(response.message)) {
+        await this.settle(operation, {});
+        return "base-moved";
+      }
+      await this.settle(operation, { status: "needs_attention", lastError: response.message });
+      return "done";
+    } catch (error) {
+      if (!dispatched || error instanceof GitHubMergeOperationError && error.outcome === "rejected") {
+        await this.clearMergeRecovery(operation);
+        await this.settle(operation, {});
+        if (dispatched && refusedForMovedBase(message(error))) return "base-moved";
+        throw error;
+      }
+      if (this.current.status === "merged" && !this.current.outstandingOperation) throw error;
+    }
+    await this.reconcileMerge(operation);
+    return "done";
+  }
+  async assertValidation(record, headSha, baseSha) {
+    const statusContext = typeof this.deps.statusContext === "string" ? this.deps.statusContext : await this.deps.statusContext({ request: this.current, headSha, baseSha });
+    if (!sameRepository(record.repository, this.current.repository) || record.sha !== headSha || record.trustedBaseSha !== baseSha || record.trustedBaseRef !== this.current.targetBranch || record.statusContext !== statusContext) {
+      throw new Error("Local CI evidence does not match the exact repository/head/base/context.");
+    }
+    if (record.status !== "succeeded" || record.outstandingRemoteStatusPublication || record.entrypointApprovalPending) {
+      throw new Error(
+        `Local CI did not produce confirmed success: ${record.error ?? record.status}.`
+      );
+    }
+  }
+  cacheMatches(record, baseSha) {
+    return cachedProofMatches(this.current, record, baseSha);
+  }
+  async reusable(baseSha) {
+    if (!this.slot && !this.cacheMatches(
+      await this.deps.inspectValidation?.(this.validationInput(baseSha)),
+      baseSha
+    ))
+      return void 0;
+    const record = await this.deps.reuseValidation?.(this.validationInput(baseSha));
+    return this.cacheMatches(record, baseSha) ? record : void 0;
+  }
+  async requiredChecks() {
+    const deadline = this.tick() + CONTROL_PLANE_TIMEOUT_MS;
+    while (this.tick() < deadline) {
+      await this.guard();
+      const checks = await (this.deps.readRequiredChecks ?? readGitHubRequiredChecks)({
+        ...this.prInput,
+        expectedHeadSha: this.current.acceptedHeadSha
+      });
+      if (checks.headSha !== this.current.acceptedHeadSha) {
+        throw new Error("Required check evidence is for a different head.");
+      }
+      if (checks.state === "fail") throw new Error("A required GitHub check failed.");
+      if (checks.state === "pass") return;
+      await this.waitUntil(deadline);
+    }
+    throw new Error(
+      "Required GitHub checks remain pending after the ten-minute control-plane deadline."
+    );
+  }
+  async processActive() {
+    for (let round = 0; round <= MAX_PREPARATIONS; round += 1) {
+      try {
+        await this.lease.checkpoint("round");
+        if (await this.processRound()) return;
+      } catch (error) {
+        if (!(error instanceof BaseMoved)) throw error;
+        await this.guard();
+        await this.save({
+          lastError: "Target branch moved during validation; preparing against the new base."
+        });
+      }
+    }
+    throw new Error("Preparation/base movement observation limit exhausted; needs attention.");
+  }
+  /** Validate and merge against the live base; false means the base moved, try the next round. */
+  async processRound() {
+    await this.guard();
+    await this.checkRepository();
+    let pr = await this.readPr();
+    this.assertAdmitted(pr);
+    let baseSha = await this.base();
+    await this.fetch(pr.headSha, baseSha);
+    if (!await (this.deps.isAncestor ?? isAncestor)({
+      repoRoot: this.current.repoRoot,
+      ancestorSha: baseSha,
+      headSha: pr.headSha
+    })) {
+      if (!this.slot) throw new CapacityRequired("Preparation needs real CI capacity.");
+      await this.prepare(baseSha);
+      await this.guard();
+      pr = await this.readPr();
+      this.assertAdmitted(pr);
+      const updatedBase = await this.base();
+      if (updatedBase !== baseSha) return false;
+      baseSha = updatedBase;
+    }
+    if (!await this.watching(baseSha, (watcher) => this.validateUnderWatch(baseSha, watcher))) {
+      return false;
+    }
+    await this.checkRepository();
+    pr = await this.readPr();
+    this.assertAdmitted(pr);
+    if (await this.base() !== baseSha) return false;
+    await this.deps.assertBatchMembers?.(this.current);
+    await this.lease.checkpoint("merge");
+    return await this.merge(baseSha) === "done";
+  }
+  /** Gate, attestation and required checks: all void once `baseSha` is no longer the base. */
+  async validateUnderWatch(baseSha, watcher) {
+    await this.checkForeignCi(baseSha);
+    await this.guard();
+    const headSha = this.current.acceptedHeadSha;
+    let record = await this.reusable(baseSha);
+    if (!record) {
+      const slot = this.slot;
+      if (!slot)
+        throw new CapacityRequired(
+          "Cached proof no longer matches; fresh validation needs capacity."
+        );
+      try {
+        record = await this.deps.validateHead({
+          ...this.validationInput(baseSha),
+          slot,
+          signal: this.lease.withSignal(watcher.signal),
+          claimHaltOverride: () => this.claimHaltOverride()
+        });
+      } catch (error) {
+        if (watcher.moved) throw new BaseMoved();
+        this.lease.throwIfLost();
+        throw error;
+      }
+    }
+    this.lease.throwIfLost();
+    await this.guard();
+    if (busy2(record, headSha)) throw new ForeignCiRace(record);
+    record = await this.waitForAttestation(record, this.validationInput(baseSha));
+    await this.guard();
+    if (busy2(record, headSha)) throw new ForeignCiRace(record);
+    if (record.entrypointApprovalPending) throw new EntrypointApprovalRequired(record);
+    await this.assertValidation(record, headSha, baseSha);
+    const pr = await this.readPr();
+    this.assertAdmitted(pr);
+    if (await this.base() !== baseSha) return false;
+    await this.requiredChecks();
+    return true;
+  }
+  async runOwnedAttempt() {
+    await this.guard(false);
+    const outstanding = this.current.outstandingOperation;
+    const priorTurn = await (this.deps.readTurn ?? readPublicationTurn)(this.target);
+    const settledBarrier = !outstanding && priorTurn?.recoveryRequired && priorTurn.ownerId === this.current.id;
+    if (!active2(this.current) && !outstanding && !settledBarrier) return;
+    if (active2(this.current) && outstanding?.kind !== "merge") {
+      let baseSha = await this.base();
+      if (!outstanding) {
+        const existing = await this.deps.inspectValidation?.(this.validationInput(baseSha));
+        if (!busy2(existing, this.current.acceptedHeadSha) || await this.headOnBase(baseSha)) {
+          await this.awaitExistingCi(baseSha, existing);
+        }
+        baseSha = await this.base();
+      }
+      await this.lease.wait({
+        checkContinue: () => this.guard(),
+        announce: (text) => this.save({ lastError: text })
+      });
+      const possibleCache = !outstanding && !this.forceCapacity && this.deps.reuseValidation !== void 0 && this.cacheMatches(
+        await this.deps.inspectValidation?.(this.validationInput(baseSha)),
+        baseSha
+      );
+      if (!possibleCache) {
+        this.slot = await this.deps.acquireSlot({
+          request: this.current,
+          checkContinue: () => this.guard()
+        });
+      }
+      await this.guard();
+      await this.lease.acquire(baseSha);
+    }
+    this.turn = await (this.deps.acquireTurn ?? acquirePublicationTurn)({
+      ...this.target,
+      ownerId: this.current.id,
+      recover: true,
+      signal: this.deps.signal
+    });
+    await this.guard(false);
+    if (!outstanding || outstanding.kind === "update") await this.turn.clearRecovery();
+    else await this.turn.requireRecovery("Recovering an outstanding expected-head merge.");
+    await this.verifyOriginalLineage();
+    if (outstanding?.kind === "merge") {
+      await this.reconcileMerge(outstanding);
+      return;
+    }
+    if (outstanding?.kind === "update") await this.reconcileUpdate(outstanding);
+    if (!active2(this.current)) return;
+    await this.save({ status: "running", lastError: this.lease.statusNote() });
+    await this.processActive();
+  }
+  async releaseResources() {
+    const turn = this.turn;
+    const slot = this.slot;
+    this.turn = void 0;
+    this.slot = void 0;
+    try {
+      await turn?.release();
+    } finally {
+      try {
+        await slot?.release();
+      } finally {
+        await this.lease.release();
+      }
+    }
+  }
+  /** A lease problem re-queues for the lease: resources are released and the wait restarts. */
+  async runLeasedAttempt() {
+    for (; ; ) {
+      try {
+        return await this.runOwnedAttempt();
+      } catch (error) {
+        if (!(error instanceof LeaseRetry)) throw error;
+        await this.releaseResources();
+      }
+    }
+  }
+  async run() {
+    try {
+      let foreignCiRetries = 0;
+      let capacityFallbacks = 0;
+      for (let attempt = 0; attempt <= MAX_FOREIGN_CI_RETRIES + MAX_CAPACITY_FALLBACKS; attempt += 1) {
+        try {
+          await this.runLeasedAttempt();
+          break;
+        } catch (error) {
+          if (error instanceof CapacityRequired) {
+            await this.releaseResources();
+            if (capacityFallbacks++ === MAX_CAPACITY_FALLBACKS) {
+              throw new Error(
+                "Cached-validation capacity fallback exhausted; merge request needs attention."
+              );
+            }
+            this.forceCapacity = true;
+            await this.guard();
+            await this.save({
+              lastError: "Cached proof requires preparation or fresh validation; retrying once with real capacity."
+            });
+            continue;
+          }
+          if (!(error instanceof ForeignCiRace)) throw error;
+          await this.releaseResources();
+          if (foreignCiRetries++ === MAX_FOREIGN_CI_RETRIES) {
+            throw new Error("Foreign-CI admission retry exhausted; merge request needs attention.");
+          }
+          await this.guard();
+          await this.save({
+            lastError: "Foreign CI admission raced; waiting outside capacity/publication before one internal retry."
+          });
+          await this.awaitExistingCi(await this.base(), error.record);
+        }
+      }
+    } catch (error) {
+      if (!(error instanceof RequestChanged)) {
+        try {
+          await this.deps.assertCoordinatorOwned?.();
+          await this.disposition(error);
+        } catch (saveError) {
+          if (!(saveError instanceof RequestChanged)) throw saveError;
+        }
+      }
+    } finally {
+      await this.releaseResources();
+    }
+    return this.current;
+  }
+};
+
+// src/core/ci/merge-queue-runner.ts
+import { spawn } from "child_process";
+import { closeSync, openSync } from "fs";
+import path6 from "path";
+import { setTimeout as delay2 } from "timers/promises";
+
+// src/core/ci/merge-queue-state.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { mkdir as mkdir2, open, readFile as readFile3, rename as rename2, unlink as unlink2 } from "fs/promises";
+import path5 from "path";
+import { z as z4 } from "zod";
+
+// src/core/ci/merge-queue-types.ts
+import path4 from "path";
+import { z as z3 } from "zod";
+var MergeQueueRepositorySchema = z3.string().refine(
+  (value) => parseLocalCiRepositoryIdentity(value) !== null && value.split("/").length === 2,
+  {
+    message: "Expected a GitHub owner/repository identity."
+  }
+).transform((value) => value.trim().toLowerCase());
+var ShaSchema2 = z3.string().regex(/^[a-f0-9]{40}$/i).transform((value) => value.toLowerCase());
+var CounterSchema = z3.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var BranchSchema = z3.string().min(1);
+var RepoRootSchema = z3.string().refine(path4.isAbsolute, { message: "Expected an absolute repository root." });
+var MergeRequestCloseoutSchema = z3.object({
+  status: z3.enum(["done", "not_applicable", "needs_attention"]),
+  itemId: z3.string().min(1).optional(),
+  message: z3.string().optional()
+});
+var TrustGrantBaseSchema = z3.object({
+  /** The request the human decision was recorded for; a grant never applies to another. */
+  sourceRequestId: z3.string().uuid(),
+  grantedAt: z3.iso.datetime(),
+  /** How the human supplied it: a command-line flag or an admission-time environment alias. */
+  provenance: z3.enum(["flag", "env"])
+});
+var EntrypointFingerprintSchema = z3.string().regex(ENTRYPOINT_FINGERPRINT_PATTERN);
+var MergeTrustGrantSchema = z3.discriminatedUnion("kind", [
+  TrustGrantBaseSchema.extend({
+    kind: z3.literal("entrypoint-approval"),
+    /** `inherited` copies a predecessor request's approval (see inheritedFromRequestId). */
+    provenance: z3.enum(["flag", "env", "inherited"]),
+    /**
+     * Exact-head binding (the approved candidate head SHA) plus, when it could be
+     * computed at approval time, the fingerprint of the approved definitions: a
+     * later head whose recomputed fingerprint equals it is covered as well.
+     */
+    scope: z3.object({ headSha: ShaSchema2, fingerprint: EntrypointFingerprintSchema.optional() }),
+    /** For `inherited` provenance: the request whose approval this copies. */
+    inheritedFromRequestId: z3.string().uuid().optional()
+  }),
+  TrustGrantBaseSchema.extend({
+    kind: z3.literal("halt-override"),
+    /** Set once the override bypassed a halt; `consumedHeadSha` is the head it covered. */
+    consumedAt: z3.iso.datetime().optional(),
+    consumedHeadSha: ShaSchema2.optional()
+  })
+]);
+var EnqueueMergeRequestInputSchema = z3.object({
+  repository: MergeQueueRepositorySchema,
+  targetBranch: BranchSchema,
+  /** The store resolves linked worktrees to their stable canonical repository. */
+  repoRoot: RepoRootSchema,
+  prNumber: z3.number().int().positive(),
+  reviewedSha: ShaSchema2,
+  headBranch: BranchSchema,
+  mergeMethod: z3.enum(["merge", "squash", "rebase"])
+});
+var MergeRequestSchema = EnqueueMergeRequestInputSchema.extend({
+  schemaVersion: z3.literal(1),
+  id: z3.string().uuid(),
+  version: CounterSchema.min(1),
+  acceptedHeadSha: ShaSchema2,
+  status: z3.enum([
+    "queued",
+    "running",
+    "awaiting_approval",
+    "needs_attention",
+    "cancelled",
+    "merged"
+  ]),
+  createdAt: z3.iso.datetime(),
+  updatedAt: z3.iso.datetime(),
+  order: CounterSchema.min(1),
+  preparationCount: CounterSchema,
+  recoveryCount: CounterSchema,
+  preparedHeads: z3.array(
+    z3.object({
+      sha: ShaSchema2,
+      parentSha: ShaSchema2,
+      baseSha: ShaSchema2
+    })
+  ),
+  outstandingOperation: z3.object({
+    kind: z3.enum(["update", "merge"]),
+    expectedHeadSha: ShaSchema2,
+    baseSha: ShaSchema2.optional(),
+    requestedAt: z3.iso.datetime()
+  }).optional(),
+  lastError: z3.string().optional(),
+  mergeCommit: ShaSchema2.optional(),
+  closeout: MergeRequestCloseoutSchema.optional(),
+  /** An automatic batch request: the admitted single requests it lands. */
+  batchMembers: z3.array(
+    z3.object({
+      requestId: z3.string().uuid(),
+      prNumber: z3.number().int().positive(),
+      reviewedSha: ShaSchema2
+    })
+  ).min(2).optional(),
+  /**
+   * An explicit batch PR (`ci merge <pr>:<sha> <pr>:<sha> ...`): the member PR
+   * numbers it was assembled from. Used to recognize a replacement batch for
+   * entrypoint approval inheritance and to match member-linked backlog items at
+   * closeout; it does not change how the batch lands.
+   */
+  batchPrNumbers: z3.array(z3.number().int().positive()).min(2).optional(),
+  /** A member held by an automatic batch; it is not selected singly meanwhile. */
+  batchedInto: z3.object({ requestId: z3.string().uuid(), prNumber: z3.number().int().positive() }).optional(),
+  /** One automatic batch attempt was spent; this request now lands on its own. */
+  batchAttempted: z3.literal(true).optional(),
+  /**
+   * Set when validation stopped at a trusted verification entrypoint change that
+   * needs a human decision. The request waits as `awaiting_approval` until a
+   * matching approval releases it (`releasedAt`), and keeps the record afterwards
+   * so status can say the run is an approved one.
+   */
+  entrypointHold: z3.object({
+    /** The candidate head the entrypoint check blocked; an approval must name it. */
+    headSha: ShaSchema2,
+    /** What Local CI reported as redefined, for status. */
+    reason: z3.string().min(1),
+    /** The redefinition fingerprint Local CI computed for the blocked head, for status. */
+    fingerprint: EntrypointFingerprintSchema.optional(),
+    heldAt: z3.iso.datetime(),
+    releasedAt: z3.iso.datetime().optional()
+  }).optional(),
+  /** Human trust decisions recorded at admission; absent on requests saved before they existed. */
+  trustGrants: z3.array(MergeTrustGrantSchema).max(2).optional(),
+  /** When supplied on a worker save, must match the current coordinator token. */
+  workerToken: z3.string().uuid().optional()
+});
+var MergeCoordinatorClaimSchema = z3.object({
+  repository: MergeQueueRepositorySchema,
+  token: z3.string().uuid(),
+  ownerPid: z3.number().int().positive(),
+  ownerPidIdentity: z3.string().min(1),
+  claimedAt: z3.iso.datetime(),
+  transferredAt: z3.iso.datetime().optional(),
+  ready: z3.boolean(),
+  readyAt: z3.iso.datetime().optional()
+});
+
+// src/core/ci/merge-queue-state.ts
+var QueueSchema = z4.object({
+  schemaVersion: z4.literal(1),
+  repository: MergeQueueRepositorySchema,
+  requests: z4.array(MergeRequestSchema),
+  coordinator: MergeCoordinatorClaimSchema.optional(),
+  // A fast drainer may release before its launcher polls. Keep the child-written
+  // receipt independently of the active claim, including across later launches.
+  acknowledgedCoordinatorTokens: z4.array(z4.string().uuid()).default([])
+});
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "merged",
+  "needs_attention",
+  "cancelled"
+]);
+function active3(request) {
+  return request.status === "queued" || request.status === "running";
+}
+function openIntent(request) {
+  return active3(request) || request.status === "awaiting_approval";
+}
+function holdsQueueAnchor(request) {
+  return openIntent(request) || request.outstandingOperation?.kind === "merge";
+}
+function timestampAfter(previous) {
+  return new Date(Math.max(Date.now(), Date.parse(previous) + 1)).toISOString();
+}
+function bump(request, changes) {
+  return MergeRequestSchema.parse({
+    ...request,
+    ...changes,
+    version: request.version + 1,
+    updatedAt: timestampAfter(request.updatedAt)
+  });
+}
+function identity(request) {
+  return JSON.stringify([
+    request.repository,
+    request.targetBranch,
+    request.repoRoot,
+    request.id,
+    request.prNumber,
+    request.reviewedSha,
+    request.headBranch,
+    request.mergeMethod,
+    request.createdAt,
+    request.order
+  ]);
+}
+function assertTransition(current, next) {
+  if (identity(current) !== identity(next)) {
+    throw new Error("Merge request identity cannot change during compareAndSave.");
+  }
+  if (next.preparationCount < current.preparationCount || next.recoveryCount < current.recoveryCount) {
+    throw new Error("Merge request attempt counters cannot decrease.");
+  }
+  if (current.preparedHeads.some(
+    (head, index) => JSON.stringify(head) !== JSON.stringify(next.preparedHeads[index])
+  )) {
+    throw new Error("Merge request preparation lineage cannot be removed or rewritten.");
+  }
+  const settlesMerge = current.outstandingOperation?.kind === "merge" && next.status === "merged" && next.mergeCommit !== void 0 && next.outstandingOperation === void 0;
+  if (!active3(current) && next.status !== current.status && !settlesMerge) {
+    throw new Error("A stopped merge request cannot be reopened.");
+  }
+  if (current.mergeCommit && next.mergeCommit !== current.mergeCommit) {
+    throw new Error("A confirmed merge result cannot be removed or rewritten.");
+  }
+}
+var MergeQueueStore = class {
+  constructor(root = getLocalCiStateRoot(), options = {}) {
+    this.options = options;
+    this.root = path5.resolve(root);
+  }
+  options;
+  root;
+  /** Requests as last written under each held mutex, for landing history. */
+  written = /* @__PURE__ */ new WeakMap();
+  /** Append one landing entry per request that entered a terminal status; never throws. */
+  async logTerminalTransitions(prior, requests) {
+    for (const request of requests) {
+      if (!TERMINAL_STATUSES.has(request.status)) continue;
+      if (prior.get(request.id) === request.status) continue;
+      await appendLandingLogEntry(this.root, "queue", queueLandingFields(request));
+    }
+  }
+  filePath(repository) {
+    return path5.join(this.root, "merge-queue", repoStateKey(repository), "queue.json");
+  }
+  async readQueue(repository) {
+    const file = this.filePath(repository);
+    let raw;
+    try {
+      raw = await readFile3(file, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return { schemaVersion: 1, repository, requests: [], acknowledgedCoordinatorTokens: [] };
+      }
+      throw new Error(`Unable to read merge queue state at ${file}.`, { cause: error });
+    }
+    try {
+      const queue = QueueSchema.parse(JSON.parse(raw));
+      const anchor = queue.requests.find(holdsQueueAnchor);
+      const ids = /* @__PURE__ */ new Set();
+      const orders = /* @__PURE__ */ new Set();
+      if (queue.repository !== repository || queue.coordinator && queue.coordinator.repository !== repository) {
+        throw new Error("Repository identity does not match the queue path.");
+      }
+      for (const request of queue.requests) {
+        if (request.repository !== repository || holdsQueueAnchor(request) && (request.targetBranch !== anchor?.targetBranch || request.repoRoot !== anchor?.repoRoot) || ids.has(request.id) || orders.has(request.order)) {
+          throw new Error("Request identity or ordering does not match its queue.");
+        }
+        ids.add(request.id);
+        orders.add(request.order);
+      }
+      return queue;
+    } catch (error) {
+      throw new Error(`Invalid merge queue state at ${file}.`, { cause: error });
+    }
+  }
+  async writeQueue(queue, fence) {
+    const file = this.filePath(queue.repository);
+    const temporary = `${file}.${process.pid}.${randomUUID2()}.tmp`;
+    try {
+      const handle = await open(temporary, "wx", 384);
+      try {
+        await handle.writeFile(`${JSON.stringify(QueueSchema.parse(queue), null, 2)}
+`, "utf8");
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      await this.options.beforePublish?.();
+      await fence.assertOwned();
+      await rename2(temporary, file);
+      this.written.set(fence, queue.requests);
+    } catch (error) {
+      await unlink2(temporary).catch(() => void 0);
+      throw error;
+    }
+  }
+  async mutate(repository, operation, fn) {
+    const normalized = MergeQueueRepositorySchema.parse(repository);
+    const target = `${this.filePath(normalized)}.mutex`;
+    await mkdir2(path5.dirname(target), { recursive: true, mode: 448 });
+    const fence = await acquireFencedFileLock(target, {
+      stale: 3e4,
+      retries: { retries: 100, minTimeout: 50, maxTimeout: 100, factor: 1.2 },
+      description: "Merge queue state mutex"
+    });
+    let priorStatus;
+    try {
+      await this.options.afterLockAcquired?.(operation);
+      await fence.assertOwned();
+      const queue = await this.readQueue(normalized);
+      await fence.assertOwned();
+      priorStatus = new Map(queue.requests.map((request) => [request.id, request.status]));
+      return await fn(queue, fence);
+    } finally {
+      const written = this.written.get(fence);
+      this.written.delete(fence);
+      await fence();
+      if (written && priorStatus) await this.logTerminalTransitions(priorStatus, written);
+    }
+  }
+  async list(repository) {
+    const queue = await this.readQueue(MergeQueueRepositorySchema.parse(repository));
+    return queue.requests.sort((a, b) => a.order - b.order);
+  }
+  async read(repository, id) {
+    return (await this.list(repository)).find((request) => request.id === id);
+  }
+  async latest(repository, prNumber) {
+    return (await this.list(repository)).filter((request) => request.prNumber === prNumber).at(-1);
+  }
+  /** Only fresh positive admission may request resumeStopped; recovery omits it. */
+  async enqueue(input, options = {}) {
+    const parsed = EnqueueMergeRequestInputSchema.parse(input);
+    const resolveRoot = this.options.resolveRepoRoot ?? resolveCanonicalMainRepoRoot;
+    const repoRoot = path5.resolve(await resolveRoot(parsed.repoRoot));
+    return this.mutate(parsed.repository, "enqueue", async (queue, fence) => {
+      const anchor = queue.requests.find(holdsQueueAnchor);
+      if (anchor && anchor.targetBranch !== parsed.targetBranch) {
+        throw new Error("Merge queue target branch differs from the recorded default target.");
+      }
+      if (anchor && anchor.repoRoot !== repoRoot) {
+        throw new Error("Merge queue canonical repository root differs from the recorded root.");
+      }
+      const existing = queue.requests.filter(
+        (request2) => request2.prNumber === parsed.prNumber && request2.reviewedSha === parsed.reviewedSha
+      ).sort((a, b) => b.order - a.order)[0];
+      const resumedFrom = options.resumeStopped && (existing?.status === "cancelled" || existing?.status === "needs_attention") ? existing : void 0;
+      if (existing && !resumedFrom) {
+        if (!options.trust || !openIntent(existing)) return { request: existing, created: false };
+        const now2 = /* @__PURE__ */ new Date();
+        const trustGrants = recordTrustGrants(
+          existing.id,
+          options.trust,
+          existing.trustGrants,
+          now2
+        );
+        const updated = bump(existing, {
+          trustGrants,
+          ...releaseIfApproved({ ...existing, trustGrants }, now2)
+        });
+        queue.requests = queue.requests.map(
+          (current) => current.id === existing.id ? updated : current
+        );
+        await this.writeQueue(queue, fence);
+        return { request: updated, created: false };
+      }
+      if (resumedFrom && queue.requests.some(
+        (request2) => request2.prNumber === parsed.prNumber && request2.outstandingOperation?.kind === "merge"
+      )) {
+        throw new Error(
+          "Cannot resume a request while this PR has an unresolved dispatched merge."
+        );
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const id = randomUUID2();
+      const inherited = options.trust?.entrypointApproval ? void 0 : inheritEntrypointApproval(queue.requests, parsed.prNumber, options.batchPrNumbers);
+      const trust = options.trust || inherited ? { ...options.trust, ...inherited ? { entrypointApproval: inherited } : {} } : void 0;
+      const request = MergeRequestSchema.parse({
+        ...parsed,
+        repoRoot,
+        schemaVersion: 1,
+        id,
+        ...trust ? { trustGrants: recordTrustGrants(id, trust, void 0, new Date(now)) } : {},
+        ...options.batchPrNumbers ? { batchPrNumbers: options.batchPrNumbers } : {},
+        version: 1,
+        acceptedHeadSha: resumedFrom?.acceptedHeadSha ?? parsed.reviewedSha,
+        status: "queued",
+        createdAt: now,
+        updatedAt: now,
+        order: queue.requests.reduce((max, current) => Math.max(max, current.order), 0) + 1,
+        preparationCount: resumedFrom?.preparationCount ?? 0,
+        recoveryCount: resumedFrom?.recoveryCount ?? 0,
+        preparedHeads: resumedFrom?.preparedHeads ?? [],
+        // A dispatched update may still need its mechanical result verified.
+        // Its attempt was already charged; do not forget it on fresh admission.
+        outstandingOperation: resumedFrom?.outstandingOperation
+      });
+      queue.requests = queue.requests.map(
+        (current) => current.prNumber === parsed.prNumber && openIntent(current) ? bump(current, {
+          status: "cancelled",
+          lastError: `Superseded by reviewed SHA ${parsed.reviewedSha}.`
+        }) : current
+      );
+      queue.requests.push(request);
+      await this.writeQueue(queue, fence);
+      return { request, created: true };
+    });
+  }
+  /**
+   * Spend the one automatic batch attempt of each still-unstarted request before
+   * any remote effect, so a crash mid-batch leaves singles, never a retry loop.
+   */
+  async markBatchAttempt(repository, ids) {
+    return this.mutate(repository, "batch", async (queue, fence) => {
+      const marked = [];
+      queue.requests = queue.requests.map((current) => {
+        if (!ids.includes(current.id) || current.status !== "queued" || current.batchAttempted || current.batchedInto || current.outstandingOperation)
+          return current;
+        const next = bump(current, { batchAttempted: true });
+        marked.push(next);
+        return next;
+      });
+      if (marked.length > 0) await this.writeQueue(queue, fence);
+      return marked.sort((a, b) => a.order - b.order);
+    });
+  }
+  /** Queue an automatic batch and hold its members in the same atomic write. */
+  async enqueueBatch(batch, members) {
+    const first = members[0];
+    if (!first || members.length < 2) throw new Error("A merge batch needs at least two members.");
+    return this.mutate(first.repository, "batch", async (queue, fence) => {
+      const current = members.map((member) => queue.requests.find((r) => r.id === member.id));
+      if (current.some(
+        (record, index) => !record || record.version !== members[index].version || record.status !== "queued" || record.batchedInto !== void 0 || record.outstandingOperation !== void 0
+      )) {
+        throw new Error("A batch member changed before the batch was queued.");
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const request = MergeRequestSchema.parse({
+        repository: first.repository,
+        targetBranch: first.targetBranch,
+        repoRoot: first.repoRoot,
+        prNumber: batch.prNumber,
+        reviewedSha: batch.reviewedSha,
+        headBranch: batch.headBranch,
+        mergeMethod: first.mergeMethod,
+        schemaVersion: 1,
+        id: randomUUID2(),
+        version: 1,
+        acceptedHeadSha: batch.reviewedSha,
+        status: "queued",
+        createdAt: now,
+        updatedAt: now,
+        order: queue.requests.reduce((max, r) => Math.max(max, r.order), 0) + 1,
+        preparationCount: 0,
+        recoveryCount: 0,
+        preparedHeads: [],
+        batchMembers: members.map((member) => ({
+          requestId: member.id,
+          prNumber: member.prNumber,
+          reviewedSha: member.acceptedHeadSha
+        }))
+      });
+      queue.requests = queue.requests.map(
+        (record) => members.some((member) => member.id === record.id) ? bump(record, { batchedInto: { requestId: request.id, prNumber: batch.prNumber } }) : record
+      );
+      queue.requests.push(request);
+      await this.writeQueue(queue, fence);
+      return request;
+    });
+  }
+  async compareAndSave(expected, next) {
+    const previous = MergeRequestSchema.parse(expected);
+    const candidate = MergeRequestSchema.parse(next);
+    if (identity(previous) !== identity(candidate)) {
+      throw new Error("compareAndSave requires the same merge request identity.");
+    }
+    return this.mutate(previous.repository, "save", async (queue, fence) => {
+      const index = queue.requests.findIndex((request) => request.id === previous.id);
+      const current = queue.requests[index];
+      if (!current) throw new Error("Merge request no longer exists.");
+      if (current.version !== previous.version) return { applied: false, record: current };
+      assertTransition(current, candidate);
+      if (candidate.workerToken) {
+        const claim = this.requireClaim(queue, candidate.workerToken);
+        this.requireOwnerProcess(claim);
+      } else if (current.workerToken && active3(candidate)) {
+        throw new Error("An active worker save cannot discard coordinator ownership.");
+      }
+      const saved = bump(current, candidate);
+      queue.requests[index] = saved;
+      await this.writeQueue(queue, fence);
+      return { applied: true, record: saved };
+    });
+  }
+  /**
+   * Release one held request back to the queue if it is still the version the
+   * caller judged approvable; a cancelled, superseded or changed request stays.
+   */
+  async releaseApprovalHold(repository, id, expectedVersion, now = /* @__PURE__ */ new Date()) {
+    return this.mutate(repository, "resume", async (queue, fence) => {
+      const index = queue.requests.findIndex((request) => request.id === id);
+      const current = queue.requests[index];
+      if (!current || current.version !== expectedVersion) return void 0;
+      const patch = releaseHold(current, now);
+      if (!patch.status) return void 0;
+      const released = bump(current, patch);
+      queue.requests[index] = released;
+      await this.writeQueue(queue, fence);
+      return released;
+    });
+  }
+  async cancel(repository, prNumber, reviewedSha) {
+    return this.mutate(repository, "cancel", async (queue, fence) => {
+      const current = queue.requests.filter(
+        (request) => request.prNumber === prNumber && (reviewedSha === void 0 || request.reviewedSha === reviewedSha.toLowerCase())
+      ).sort((a, b) => b.order - a.order)[0];
+      if (!current || current.status === "merged" || current.status === "cancelled") return current;
+      const cancelled = bump(current, { status: "cancelled" });
+      queue.requests[queue.requests.indexOf(current)] = cancelled;
+      await this.writeQueue(queue, fence);
+      return cancelled;
+    });
+  }
+  ownership(claim) {
+    return (this.options.processOwnership ?? processOwnershipState)(
+      claim.ownerPid,
+      claim.ownerPidIdentity,
+      claim.claimedAt
+    );
+  }
+  requireClaim(queue, token) {
+    if (!queue.coordinator || queue.coordinator.token !== token) {
+      throw new Error("Merge coordinator ownership changed.");
+    }
+    return queue.coordinator;
+  }
+  requireOwnerProcess(claim) {
+    if (claim.ownerPid !== process.pid || this.ownership(claim) !== "owned") {
+      throw new Error(
+        "Only the recorded merge coordinator owner process may perform this operation."
+      );
+    }
+  }
+  async claimCoordinator(repository) {
+    return this.mutate(repository, "claim", async (queue, fence) => {
+      if (queue.coordinator && this.ownership(queue.coordinator) !== "reclaimable")
+        return void 0;
+      const ownerPidIdentity = (this.options.processIdentity ?? readProcessIdentity)(process.pid);
+      if (!ownerPidIdentity)
+        throw new Error("Unable to establish merge coordinator process identity.");
+      const claim = MergeCoordinatorClaimSchema.parse({
+        repository: queue.repository,
+        token: randomUUID2(),
+        ownerPid: process.pid,
+        ownerPidIdentity,
+        claimedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ready: false
+      });
+      queue.coordinator = claim;
+      await this.writeQueue(queue, fence);
+      return claim;
+    });
+  }
+  async transferCoordinator(repository, token, pid, identity2) {
+    return this.mutate(repository, "transfer", async (queue, fence) => {
+      const current = this.requireClaim(queue, token);
+      if (current.ownerPid === pid && current.ownerPidIdentity === identity2) return current;
+      this.requireOwnerProcess(current);
+      if (current.ready) throw new Error("A ready coordinator cannot be transferred.");
+      const transferred = MergeCoordinatorClaimSchema.parse({
+        ...current,
+        ownerPid: pid,
+        ownerPidIdentity: identity2,
+        transferredAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ready: false,
+        readyAt: void 0
+      });
+      if (this.ownership(transferred) !== "owned") {
+        throw new Error("Unable to verify the new merge coordinator process identity.");
+      }
+      queue.coordinator = transferred;
+      await this.writeQueue(queue, fence);
+      return transferred;
+    });
+  }
+  async acknowledgeCoordinator(repository, token) {
+    return this.mutate(repository, "acknowledge", async (queue, fence) => {
+      const current = this.requireClaim(queue, token);
+      this.requireOwnerProcess(current);
+      if (!current.transferredAt) {
+        throw new Error("Only a transferred worker can acknowledge merge coordinator readiness.");
+      }
+      if (current.ready && queue.acknowledgedCoordinatorTokens.includes(token)) return current;
+      const ready = {
+        ...current,
+        ready: true,
+        readyAt: current.readyAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      };
+      queue.coordinator = ready;
+      if (!queue.acknowledgedCoordinatorTokens.includes(token)) {
+        queue.acknowledgedCoordinatorTokens.push(token);
+      }
+      await this.writeQueue(queue, fence);
+      return ready;
+    });
+  }
+  async readCoordinator(repository) {
+    return (await this.readQueue(MergeQueueRepositorySchema.parse(repository))).coordinator;
+  }
+  async hasCoordinatorAcknowledgement(repository, token) {
+    const queue = await this.readQueue(MergeQueueRepositorySchema.parse(repository));
+    return queue.acknowledgedCoordinatorTokens.includes(token);
+  }
+  async releaseCoordinator(repository, token, options = {}) {
+    return this.mutate(repository, "release", async (queue, fence) => {
+      const current = queue.coordinator;
+      if (!current || current.token !== token) return false;
+      const ownership2 = this.ownership(current);
+      if (ownership2 === "unknown" || ownership2 === "owned" && current.ownerPid !== process.pid)
+        return false;
+      if (options.onlyIfIdle && queue.requests.some(
+        (request) => runnable(request, queue.requests) || request.outstandingOperation?.kind === "merge"
+      ))
+        return false;
+      if (options.startupError) {
+        queue.requests = queue.requests.map(
+          (request) => request.workerToken === token && active3(request) ? bump(request, {
+            status: request.recoveryCount >= 1 ? "needs_attention" : request.status,
+            lastError: options.startupError
+          }) : request
+        );
+      }
+      queue.coordinator = void 0;
+      await this.writeQueue(queue, fence);
+      return true;
+    });
+  }
+};
+
+// src/core/ci/merge-queue-runner.ts
+var STARTUP_TIMEOUT_MS = 3e4;
+var POLL_MS = 50;
+var MAX_OWNERSHIP_RACES = 3;
+var MAX_WORKER_RECOVERIES = 1;
+function active4(request) {
+  return request.status === "queued" || request.status === "running";
+}
+function unresolvedMerge(request) {
+  return request.outstandingOperation?.kind === "merge";
+}
+function releasedHold(request) {
+  return request.status === "queued" && request.workerToken === void 0 && request.entrypointHold?.releasedAt !== void 0;
+}
+function pendingCloseout(request) {
+  return request.status === "merged" && request.closeout === void 0;
+}
+function selectRequest(requests) {
+  const waiting = requests.filter((request) => runnable(request, requests)).sort((a, b) => queuePosition(a, requests) - queuePosition(b, requests));
+  return requests.find(unresolvedMerge) ?? waiting[0] ?? requests.find(pendingCloseout);
+}
+function ownership(claim, deps) {
+  return (deps.processOwnership ?? processOwnershipState)(
+    claim.ownerPid,
+    claim.ownerPidIdentity,
+    claim.claimedAt
+  );
+}
+function wait(deps) {
+  return (deps.sleep ?? delay2)(deps.pollMs ?? POLL_MS);
+}
+async function requireWorker(store, repository, token) {
+  const claim = await store.readCoordinator(repository);
+  if (!claim || claim.token !== token || claim.ownerPid !== process.pid || processOwnershipState(claim.ownerPid, claim.ownerPidIdentity, claim.claimedAt) !== "owned")
+    throw new Error("Merge coordinator ownership changed.");
+  return claim;
+}
+async function adoptRequest(request, store, token, activate) {
+  await requireWorker(store, request.repository, token);
+  const previousAttempt = request.workerToken !== token && (request.workerToken !== void 0 || request.status === "running");
+  const recovering = active4(request) && previousAttempt;
+  const exhausted = recovering && request.recoveryCount >= MAX_WORKER_RECOVERIES;
+  const next = {
+    ...request,
+    workerToken: token,
+    recoveryCount: recovering && !exhausted ? request.recoveryCount + 1 : request.recoveryCount,
+    status: exhausted ? "needs_attention" : activate && active4(request) ? "running" : request.status,
+    lastError: exhausted ? "Automatic merge worker recovery exhausted; fresh reviewed authorization is required." : request.lastError
+  };
+  if (next.workerToken === request.workerToken && next.status === request.status && next.recoveryCount === request.recoveryCount)
+    return request;
+  return (await store.compareAndSave(request, next)).record;
+}
+async function terminalAcknowledgement(store, repository, token) {
+  if (!await store.hasCoordinatorAcknowledgement(repository, token)) return void 0;
+  const requests = await store.list(repository);
+  const owned = requests.filter((request) => request.workerToken === token);
+  if (owned.length === 0 || owned.some((request) => runnable(request, requests))) {
+    return void 0;
+  }
+  const blocker = requests.find(unresolvedMerge);
+  if (requests.some((request) => runnable(request, requests)) && !blocker) return void 0;
+  const newestByPr = /* @__PURE__ */ new Map();
+  for (const request of owned) newestByPr.set(request.prNumber, request);
+  const summary = [...newestByPr.values()].map((request) => {
+    if (request.status === "needs_attention") return `PR #${request.prNumber} needs attention.`;
+    if (request.status === "awaiting_approval") {
+      return `PR #${request.prNumber} awaits entrypoint approval.`;
+    }
+    if (request.status === "cancelled") return `PR #${request.prNumber} cancelled.`;
+    return `PR #${request.prNumber} merged.${request.closeout === void 0 ? " Bookkeeping is pending." : request.closeout.status === "needs_attention" ? " Bookkeeping needs attention." : ""}`;
+  });
+  if (blocker)
+    summary.push(`Publication is blocked by the unresolved merge for PR #${blocker.prNumber}.`);
+  return { accepted: true, message: summary.join(" ") };
+}
+async function settledQueueReceipt(store, repository) {
+  const last = (await store.list(repository)).at(-1);
+  const receipt = last?.workerToken ? await terminalAcknowledgement(store, repository, last.workerToken) : void 0;
+  return receipt ? { ...receipt, spawned: false } : { accepted: false, spawned: false, message: "No runnable merge intent remains." };
+}
+async function awaitAcknowledgement(store, repository, token, deadline, deps, childError = () => void 0) {
+  do {
+    const claim = await store.readCoordinator(repository);
+    const terminal = await terminalAcknowledgement(store, repository, token);
+    if (terminal) return terminal;
+    if (claim?.ready && ownership(claim, deps) === "owned") return { accepted: true };
+    const error = childError();
+    if (error) throw error;
+    if (!claim || ownership(claim, deps) === "reclaimable") return { accepted: false };
+    if (Date.now() >= deadline) break;
+    await wait(deps);
+  } while (Date.now() < deadline);
+  return { accepted: false };
+}
+async function abandonLaunch(child, identity2, startedAt, deps) {
+  if (!child?.pid) return;
+  const state = () => (deps.processOwnership ?? processOwnershipState)(
+    child.pid,
+    identity2,
+    (/* @__PURE__ */ new Date()).toISOString()
+  );
+  if (child.exitCode === null && child.signalCode === null && identity2 && state() === "owned") {
+    (deps.signalWorker ?? signalDetachedWorkerProcess)(child);
+    const deadline = Date.now() + 2e3;
+    while (Date.now() < deadline && state() === "owned") await delay2(25);
+  }
+  if (child.exitCode !== null || child.signalCode !== null || state() === "reclaimable") {
+    await (deps.unregisterProcess ?? unregisterDetachedWorkerProcess)(child.pid, startedAt);
+  }
+}
+async function ensureMergeQueueWorker(input, deps = {}) {
+  const repository = MergeQueueRepositorySchema.parse(input.repository);
+  const { store } = input;
+  const deadline = Date.now() + (deps.startupTimeoutMs ?? STARTUP_TIMEOUT_MS);
+  for (let race = 0; race < MAX_OWNERSHIP_RACES && Date.now() < deadline; race += 1) {
+    if (!selectRequest(await store.list(repository))) {
+      return settledQueueReceipt(store, repository);
+    }
+    const claim = await store.claimCoordinator(repository);
+    if (!claim) {
+      const existing = await store.readCoordinator(repository);
+      if (!existing) continue;
+      const acknowledgement = await awaitAcknowledgement(
+        store,
+        repository,
+        existing.token,
+        deadline,
+        deps
+      );
+      if (acknowledgement.accepted) {
+        return { ...acknowledgement, spawned: false };
+      }
+      const current = await store.readCoordinator(repository);
+      if (!current || current.token !== existing.token || ownership(current, deps) === "reclaimable")
+        continue;
+      return {
+        accepted: false,
+        spawned: false,
+        message: "Merge worker readiness is unconfirmed; intent remains recorded. Use ci reconcile to recover."
+      };
+    }
+    let child;
+    let identity2;
+    let registeredAt;
+    let launchError;
+    try {
+      const candidate = selectRequest(await store.list(repository));
+      if (!candidate) {
+        if (await store.releaseCoordinator(repository, claim.token, { onlyIfIdle: true })) {
+          return settledQueueReceipt(store, repository);
+        }
+        await store.releaseCoordinator(repository, claim.token);
+        continue;
+      }
+      await adoptRequest(candidate, store, claim.token, false);
+      if (!selectRequest(await store.list(repository))) {
+        if (!await store.releaseCoordinator(repository, claim.token, { onlyIfIdle: true })) {
+          await store.releaseCoordinator(repository, claim.token);
+          continue;
+        }
+        return {
+          accepted: false,
+          spawned: false,
+          message: "Automatic merge worker recovery exhausted; request needs attention."
+        };
+      }
+      const entryPath = input.entryPath ?? process.argv[1];
+      if (!entryPath) throw new Error("Unable to resolve the Build CLI entry path.");
+      const logPath = path6.join(
+        store.root,
+        "merge-queue",
+        repoStateKey(repository),
+        `worker-${claim.token}.log`
+      );
+      const logFd = openSync(logPath, "a", 384);
+      try {
+        child = (deps.spawn ?? spawn)(
+          process.execPath,
+          [
+            path6.resolve(entryPath),
+            "ci",
+            "merge-worker",
+            "--repository",
+            repository,
+            "--token",
+            claim.token,
+            "--state-root",
+            store.root
+          ],
+          {
+            cwd: candidate.repoRoot,
+            detached: process.platform !== "win32",
+            stdio: ["ignore", logFd, logFd],
+            env: createLocalCiDetachedChildEnv({
+              BUILD_LOCAL_CI_WORKER: "1",
+              BUILD_CI_RECONCILING: "1"
+            })
+          }
+        );
+        child.on("error", (error) => {
+          launchError = error;
+        });
+        child.unref();
+      } finally {
+        closeSync(logFd);
+      }
+      if (!child.pid) throw new Error("Merge worker did not receive a process id.");
+      while (Date.now() < deadline) {
+        if (launchError) throw launchError;
+        identity2 = (deps.processIdentity ?? readProcessIdentity)(child.pid);
+        if (identity2) break;
+        if (child.exitCode !== null || child.signalCode !== null) break;
+        await wait(deps);
+      }
+      if (!identity2) throw new Error("Merge worker process identity could not be established.");
+      registeredAt = await (deps.registerProcess ?? registerDetachedWorkerProcess)({
+        pid: child.pid,
+        taskId: `merge-queue-${claim.token}`,
+        command: "build ci merge-worker",
+        owner: "merge-queue",
+        metadata: { repository, token: claim.token }
+      });
+      await store.transferCoordinator(repository, claim.token, child.pid, identity2);
+      const acknowledgement = await awaitAcknowledgement(
+        store,
+        repository,
+        claim.token,
+        deadline,
+        deps,
+        () => {
+          if (launchError) return launchError;
+          if (child?.exitCode !== null || child?.signalCode !== null) {
+            return new Error("Merge worker exited before acknowledging responsibility.");
+          }
+          return void 0;
+        }
+      );
+      if (acknowledgement.accepted) return { ...acknowledgement, spawned: true };
+      throw new Error("Merge worker readiness was not acknowledged before the startup deadline.");
+    } catch (error) {
+      await abandonLaunch(child, identity2, registeredAt, deps);
+      const message2 = error instanceof Error ? error.message : String(error);
+      await store.releaseCoordinator(repository, claim.token, { startupError: message2 }).catch(() => false);
+      return {
+        accepted: false,
+        spawned: Boolean(child?.pid),
+        message: `${message2} Intent remains recorded; use ci reconcile to recover.`
+      };
+    }
+  }
+  return {
+    accepted: false,
+    spawned: false,
+    message: "Merge worker ownership did not settle within the bounded startup attempt."
+  };
+}
+async function waitForTransfer(store, repository, token, deps) {
+  const deadline = Date.now() + (deps.startupTimeoutMs ?? STARTUP_TIMEOUT_MS);
+  while (Date.now() < deadline) {
+    deps.signal?.throwIfAborted();
+    const claim = await store.readCoordinator(repository);
+    if (!claim || claim.token !== token)
+      throw new Error("Merge coordinator ownership changed before startup.");
+    if (claim.ownerPid === process.pid && claim.transferredAt) {
+      await requireWorker(store, repository, token);
+      return;
+    }
+    if (ownership(claim, deps) === "reclaimable")
+      throw new Error("Merge worker launcher exited before transfer.");
+    await wait(deps);
+  }
+  throw new Error("Merge worker assignment was not transferred before the startup deadline.");
+}
+async function stopRequest(store, repository, id, token, message2) {
+  const request = await store.read(repository, id);
+  if (!request) throw new Error("Merge request disappeared.");
+  if (!active4(request)) return request;
+  await requireWorker(store, repository, token);
+  return (await store.compareAndSave(request, {
+    ...request,
+    status: "needs_attention",
+    workerToken: token,
+    lastError: message2
+  })).record;
+}
+async function closeoutRequest(request, store, token, deps) {
+  if (!pendingCloseout(request)) return;
+  await requireWorker(store, request.repository, token);
+  let closeout;
+  try {
+    if (!request.mergeCommit) throw new Error("Merged request has no confirmed merge commit.");
+    if (!deps.closeout) throw new Error("Merged; bookkeeping handler is unavailable.");
+    closeout = MergeRequestCloseoutSchema.parse(await deps.closeout(request));
+  } catch (error) {
+    closeout = {
+      status: "needs_attention",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+  await store.compareAndSave(request, { ...request, workerToken: token, closeout });
+}
+async function runMergeQueueWorkerLoop(input, deps) {
+  const repository = MergeQueueRepositorySchema.parse(input.repository);
+  const store = deps.store ?? new MergeQueueStore(input.stateRoot);
+  await waitForTransfer(store, repository, input.token, deps);
+  let heartbeat;
+  let released = false;
+  const processed = /* @__PURE__ */ new Set();
+  let selectionRaces = 0;
+  try {
+    (deps.keepAwake ?? keepMacAwakeForCurrentProcess)();
+    heartbeat = await (deps.startHeartbeat ?? startDetachedWorkerRegistryHeartbeat)({
+      taskId: `merge-queue-${input.token}`,
+      command: "build ci merge-worker",
+      owner: "merge-queue",
+      metadata: { repository, token: input.token }
+    });
+    await store.acknowledgeCoordinator(repository, input.token);
+    while (!deps.signal?.aborted) {
+      await requireWorker(store, repository, input.token);
+      await deps.beforeSelect?.(store, repository, input.token).catch(() => void 0);
+      const selected = selectRequest(await store.list(repository));
+      if (!selected) {
+        released = await store.releaseCoordinator(repository, input.token, { onlyIfIdle: true });
+        if (released) return;
+        continue;
+      }
+      const request = await adoptRequest(selected, store, input.token, true);
+      if (!active4(request) && !unresolvedMerge(request) && !pendingCloseout(request)) continue;
+      if (request.workerToken !== input.token) {
+        if (++selectionRaces >= MAX_OWNERSHIP_RACES)
+          throw new Error("Merge request adoption race limit reached.");
+        continue;
+      }
+      selectionRaces = 0;
+      if (pendingCloseout(request) && !unresolvedMerge(request)) {
+        if (processed.has(request.id))
+          throw new Error("Merge closeout changed concurrently; needs attention.");
+        processed.add(request.id);
+        await closeoutRequest(request, store, input.token, deps);
+        continue;
+      }
+      if (processed.has(request.id))
+        throw new Error("Merge request processing attempt already consumed.");
+      processed.add(request.id);
+      try {
+        await deps.processRequest(request, store);
+      } catch (error) {
+        await stopRequest(
+          store,
+          repository,
+          request.id,
+          input.token,
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+      let current = await store.read(repository, request.id);
+      if (!current) throw new Error("Merge request disappeared after processing.");
+      if (current.status === "awaiting_approval") processed.delete(request.id);
+      else if (releasedHold(current)) {
+        processed.delete(request.id);
+        continue;
+      }
+      if (active4(current)) {
+        current = await stopRequest(
+          store,
+          repository,
+          request.id,
+          input.token,
+          "Merge processor returned without a terminal disposition; needs attention."
+        );
+      }
+      if (unresolvedMerge(current)) return;
+      await closeoutRequest(current, store, input.token, deps);
+    }
+  } finally {
+    try {
+      await heartbeat?.unregister();
+    } finally {
+      if (!released) await store.releaseCoordinator(repository, input.token).catch(() => false);
+    }
+  }
+}
+
+// src/core/ci/nightly-backstop.ts
+import { readdir as readdir2, readFile as readFile4 } from "fs/promises";
+import path7 from "path";
+import { z as z5 } from "zod";
+var NightlyResultSchema = z5.object({
+  sha: z5.string().regex(/^[a-f0-9]{40}$/i),
+  result: z5.enum(["pass", "fail", "interrupted"]),
+  stamp: z5.string().min(1),
+  repository: z5.string().min(1),
+  reason: z5.string().optional()
+});
+var NightlyFailureSchema = z5.object({
+  kind: z5.string(),
+  phase: z5.string().optional(),
+  file: z5.string().nullable().optional(),
+  test: z5.string().nullable().optional(),
+  rerun: z5.array(z5.string()).nullable().optional()
+});
+var NightlyFailuresSchema = z5.object({ failures: z5.array(z5.unknown()) });
+var SHOWN_FAILURES = 3;
+function failureLabel(failure) {
+  if (failure.kind === "test") return `${failure.file} > ${failure.test}`;
+  if (failure.kind === "file") return `${failure.file} (file failed)`;
+  return `${failure.phase ?? "nightly"} (${failure.kind})`;
+}
+function shellQuote(arg) {
+  return /^[\w@%+=:,./-]+$/.test(arg) ? arg : `'${arg.replace(/'/g, `'\\''`)}'`;
+}
+async function describeFailures(result) {
+  const runDir = path7.dirname(result.path);
+  const detailsPath = path7.join(runDir, "failures.json");
+  let failures;
+  try {
+    const parsed = NightlyFailuresSchema.parse(JSON.parse(await readFile4(detailsPath, "utf8")));
+    failures = parsed.failures.flatMap((entry) => {
+      const failure = NightlyFailureSchema.safeParse(entry);
+      return failure.success ? [failure.data] : [];
+    });
+  } catch {
+    return {
+      text: ` Per-test detail unavailable for this run; see phase logs under ${path7.join(runDir, "phases")}.`
+    };
+  }
+  if (failures.length === 0) return { text: ` Failure detail is empty; see ${detailsPath}.` };
+  const named = failures.filter((failure) => failure.kind === "test" || failure.kind === "file");
+  const shown = (named.length > 0 ? named : failures).slice(0, SHOWN_FAILURES).map(failureLabel);
+  const more = failures.length > shown.length ? ` (+${failures.length - shown.length} more)` : "";
+  const rerun = failures.find((failure) => failure.rerun && failure.rerun.length > 0)?.rerun;
+  return {
+    text: ` Failed (${failures.length}): ${shown.join("; ")}${more}. Details: ${detailsPath}.`,
+    ...rerun ? { rerun: rerun.map(shellQuote).join(" ") } : {}
+  };
+}
+async function readNightlyOptIn(repoRoot) {
+  const result = await execGit(["config", "--local", "--get", "build.nightlyLocal"], {
+    cwd: repoRoot
+  });
+  return result.exitCode === 0 && result.stdout.trim() === "true";
+}
+async function readCompletedResults(runsDir) {
+  let entries;
+  try {
+    entries = await readdir2(runsDir);
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const results = [];
+  for (const entry of entries) {
+    const file = path7.join(runsDir, entry, "result.json");
+    let raw;
+    try {
+      raw = await readFile4(file, "utf8");
+    } catch {
+      continue;
+    }
+    let json;
+    try {
+      json = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    const parsed = NightlyResultSchema.safeParse(json);
+    if (parsed.success) results.push({ ...parsed.data, path: file });
+  }
+  return results;
+}
+function latest(results) {
+  return results.reduce(
+    (best, candidate) => !best || candidate.stamp > best.stamp ? candidate : best,
+    void 0
+  );
+}
+async function checkNightlyBackstop(input, dependencies = {}) {
+  const stateDir = dependencies.stateDir ?? (readEnv(BUILD_NIGHTLY_STATE_DIR).value || path7.join(getStateDir(), "nightly-local"));
+  if (!await (dependencies.readOptIn ?? readNightlyOptIn)(input.repoRoot)) {
+    return {
+      notice: "Info: nightly backstop not opted in on this checkout; merge admission did not consult it."
+    };
+  }
+  const results = (await readCompletedResults(path7.join(stateDir, "runs"))).filter(
+    (result) => result.result !== "interrupted" && result.repository.toLowerCase() === input.repository.toLowerCase()
+  );
+  const baseSha = input.baseSha.toLowerCase();
+  const selected = latest(results.filter((result) => result.sha.toLowerCase() === baseSha)) ?? latest(results);
+  if (!selected) {
+    return {
+      notice: `Info: no completed nightly result under ${stateDir}; merge admission did not consult it.`
+    };
+  }
+  if (selected.result === "pass") return {};
+  const scope = selected.sha.toLowerCase() === baseSha ? `base tip ${baseSha.slice(0, 12)}` : `${selected.sha.slice(0, 12)}, no result yet for base tip ${baseSha.slice(0, 12)}`;
+  const failures = await describeFailures(selected);
+  const rerunLine = failures.rerun ? `
+Rerun the first failure from the repo root:
+  ${failures.rerun}` : "";
+  return {
+    notice: `Warning: nightly backstop is red (${scope}; failed: ${selected.reason ?? "unspecified"}). Summary: ${selected.path}.${failures.text}${rerunLine}`
+  };
+}
+
+// src/core/ci/merge-queue.ts
+var PrSchema = z6.number().int().positive();
+var ShaSchema3 = z6.string().regex(/^[a-f0-9]{40}$/i).transform((value) => value.toLowerCase());
+async function checkMechanicalMergeSupport(repoRoot) {
+  const result = await execGit(["--version"], { cwd: repoRoot });
+  const version = /git version (\d+)\.(\d+)/.exec(result.stdout);
+  if (result.exitCode !== 0 || !version || Number(version[1]) < 2 || Number(version[1]) === 2 && Number(version[2]) < 38) {
+    throw new Error(
+      "Local merge handoff requires Git 2.38 or newer for mechanical merge verification."
+    );
+  }
+}
+async function resolveQueueLocation(repoRoot, dependencies) {
+  const root = await (dependencies.resolveRoot ?? resolveCanonicalMainRepoRoot)(
+    path8.resolve(repoRoot)
+  );
+  const repository = await (dependencies.resolveRepository ?? resolveOptionalGitHubRepositoryFromRemote)(root, "origin");
+  return { root, repository, store: dependencies.store ?? new MergeQueueStore() };
+}
+function requireRepositoryBinding(expected, metadata) {
+  if (expected.toLowerCase() !== metadata.repository.toLowerCase()) {
+    throw new Error("GitHub repository differs from the canonical origin.");
+  }
+}
+function assertMergeAdmissiblePullRequest(pr, repository, defaultBranch, expectedHeadSha) {
+  if (pr.state !== "open" || pr.draft)
+    throw new Error(`Merge admission requires an open, non-draft PR (#${pr.prNumber}).`);
+  if (pr.baseBranch !== defaultBranch || pr.headRepository?.toLowerCase() !== repository.toLowerCase()) {
+    throw new Error("Local merge handoff supports same-repository PRs to the default branch.");
+  }
+  if (pr.autoMergeEnabled) {
+    throw new Error(
+      "Disable independently armed GitHub auto-merge before handing this PR to Build."
+    );
+  }
+  if (pr.headSha !== expectedHeadSha) {
+    throw new Error(
+      "The PR head differs from the reviewed SHA or this request\u2019s verified preparation."
+    );
+  }
+}
+async function withApprovalFingerprint(trust, pr, location, dependencies) {
+  const approval = trust?.entrypointApproval;
+  if (!trust || !approval || approval.fingerprint) return trust;
+  if (approval.headSha.toLowerCase() !== pr.headSha.toLowerCase()) return trust;
+  const fingerprint = await (dependencies.resolveEntrypointFingerprint ?? resolveEntrypointFingerprint)({
+    repoRoot: location.root,
+    remote: "origin",
+    baseRef: location.targetBranch,
+    baseSha: pr.baseSha,
+    headSha: pr.headSha
+  });
+  return fingerprint ? { ...trust, entrypointApproval: { ...approval, fingerprint } } : trust;
+}
+async function submitMergeRequest(input, dependencies = {}) {
+  const prNumber = PrSchema.parse(input.prNumber);
+  const reviewedSha = ShaSchema3.parse(input.reviewedSha);
+  const { root, repository, store } = await resolveQueueLocation(input.repoRoot, dependencies);
+  if (!repository) throw new Error("Local merge handoff requires a supported GitHub origin.");
+  const suppliedRepository = await (dependencies.resolveRepository ?? resolveOptionalGitHubRepositoryFromRemote)(path8.resolve(input.repoRoot), "origin");
+  if (suppliedRepository?.toLowerCase() !== repository.toLowerCase()) {
+    throw new Error("The submitting worktree and canonical repository have different origins.");
+  }
+  const metadata = await (dependencies.readRepository ?? readGitHubMergeRepository)({
+    repoRoot: root,
+    repository
+  });
+  requireRepositoryBinding(repository, metadata);
+  const previous = (await store.list(repository)).reverse().find((request2) => request2.prNumber === prNumber && request2.reviewedSha === reviewedSha);
+  if (previous?.status === "merged") {
+    return {
+      request: previous,
+      accepted: true,
+      spawned: false,
+      message: previous.lastError ?? "This request already merged."
+    };
+  }
+  if (previous?.outstandingOperation?.kind === "merge") {
+    return {
+      request: previous,
+      accepted: false,
+      spawned: false,
+      message: "The prior merge outcome is unresolved. Run build ci reconcile; it settles the outcome from GitHub, or as not merged once the PR is still open at the reviewed head ten minutes after the merge request."
+    };
+  }
+  const ci = await (dependencies.inspectCi ?? inspectCiIntegration)(root, {
+    repository,
+    remote: false
+  });
+  if (ci.intentError || ci.primary !== "local" || !ci.local.enabled || ci.local.commands.length === 0) {
+    throw new Error(
+      "Configure usable local CI with build init and choose Build Local CI before handing off a merge."
+    );
+  }
+  await (dependencies.checkGit ?? checkMechanicalMergeSupport)(root);
+  const pr = await (dependencies.readPullRequest ?? readGitHubMergePullRequest)({
+    repoRoot: root,
+    repository,
+    prNumber
+  });
+  assertMergeAdmissiblePullRequest(
+    pr,
+    repository,
+    metadata.defaultBranch,
+    previous?.acceptedHeadSha ?? reviewedSha
+  );
+  const nightly = await (dependencies.checkNightly ?? checkNightlyBackstop)({
+    repoRoot: root,
+    repository,
+    baseSha: pr.baseSha
+  }).catch((error) => ({
+    notice: `Warning: could not read the nightly backstop result: ${error instanceof Error ? error.message : String(error)}`
+  }));
+  const trust = await withApprovalFingerprint(
+    input.trust,
+    pr,
+    { root, targetBranch: metadata.defaultBranch },
+    dependencies
+  );
+  const queued = await store.enqueue(
+    {
+      repository,
+      targetBranch: metadata.defaultBranch,
+      repoRoot: root,
+      prNumber,
+      reviewedSha,
+      headBranch: pr.headBranch,
+      mergeMethod: resolveGitHubMergeMethod(metadata)
+    },
+    {
+      resumeStopped: true,
+      ...trust ? { trust } : {},
+      ...input.batchPrNumbers ? { batchPrNumbers: input.batchPrNumbers } : {}
+    }
+  );
+  const launch = await (dependencies.ensureWorker ?? ensureMergeQueueWorker)({
+    repository: queued.request.repository,
+    store
+  });
+  const request = await store.read(repository, queued.request.id) ?? queued.request;
+  return {
+    request,
+    accepted: request.status === "merged" || // Held for an entrypoint approval: the intent is durable and needs no worker yet.
+    request.status === "awaiting_approval" || launch.accepted && (request.status === "queued" || request.status === "running"),
+    spawned: launch.spawned,
+    message: request.lastError ?? (request.status === "awaiting_approval" ? approvalNotice(request) : launch.message),
+    ...nightly.notice ? { nightly: nightly.notice } : {}
+  };
+}
+async function cancelMergeRequest(input, dependencies = {}) {
+  const { repository, store } = await resolveQueueLocation(input.repoRoot, dependencies);
+  if (!repository) throw new Error("Local merge handoff requires a supported GitHub origin.");
+  return store.cancel(
+    repository,
+    PrSchema.parse(input.prNumber),
+    input.reviewedSha === void 0 ? void 0 : ShaSchema3.parse(input.reviewedSha)
+  );
+}
+async function inspectMergeQueue(input, dependencies = {}) {
+  const { repository, store } = await resolveQueueLocation(input.repoRoot, dependencies);
+  if (!repository) return [];
+  const records = await store.list(repository);
+  if (input.prNumber === void 0) return records;
+  const prNumber = PrSchema.parse(input.prNumber);
+  return records.filter((request) => request.prNumber === prNumber);
+}
+async function retireSettledUpdates(store, repository, dependencies) {
+  const readPullRequest = dependencies.readPullRequest ?? readGitHubMergePullRequest;
+  for (const request of await store.list(repository)) {
+    if (request.status === "queued" || request.status === "running") continue;
+    if (request.outstandingOperation?.kind !== "update") continue;
+    const pr = await readPullRequest({
+      repoRoot: request.repoRoot,
+      repository: request.repository,
+      prNumber: request.prNumber
+    }).catch(() => void 0);
+    if (pr?.state !== "merged") continue;
+    await store.compareAndSave(request, {
+      ...request,
+      workerToken: void 0,
+      outstandingOperation: void 0
+    }).catch(() => void 0);
+  }
+}
+function approvalNotice(request) {
+  return `Awaiting entrypoint approval: ${request.entrypointHold?.reason ?? "trusted verification entrypoint changed"}. After reviewing the change, approve with: ${approvalCommand(request)}`;
+}
+function approvalResumeDependencies(stateRoot, dependencies = {}) {
+  return {
+    readPullRequest: (request) => (dependencies.readPullRequest ?? readGitHubMergePullRequest)({
+      repoRoot: request.repoRoot,
+      repository: request.repository,
+      prNumber: request.prNumber
+    }),
+    inspectValidation: (request) => (dependencies.inspectValidation ?? inspectMergeValidation)(request, stateRoot)
+  };
+}
+async function reconcileMergeQueue(input, dependencies = {}) {
+  const { repository, store } = await resolveQueueLocation(input.repoRoot, dependencies);
+  if (!repository) return [];
+  await retireSettledUpdates(store, repository, dependencies);
+  await resumeApprovedHolds(
+    store,
+    repository,
+    approvalResumeDependencies(store.root, dependencies)
+  );
+  const records = await store.list(repository);
+  if (records.some(
+    (request) => request.status === "queued" || request.status === "running" || request.outstandingOperation?.kind === "merge" || request.status === "merged" && request.closeout === void 0
+  )) {
+    const launch = await (dependencies.ensureWorker ?? ensureMergeQueueWorker)({
+      repository,
+      store
+    });
+    if (!launch.accepted) {
+      throw new Error(launch.message ?? "Merge queue worker responsibility was not acknowledged.");
+    }
+  }
+  return store.list(repository);
+}
+var mergeBatching = (stateRoot) => ({
+  enabled: async (repoRoot) => resolveMergeBatchingEnabled(repoRoot),
+  ownCiPassed: async (request) => (await inspectMergeValidation(request, stateRoot))?.status === "succeeded",
+  // The context is read from the live target tip's committed config, as the
+  // publisher does; an unresolvable or unreadable status skips batching.
+  readOwnCiStatus: async (request) => readGitHubCommitStatusDetail({
+    repository: request.repository,
+    sha: request.reviewedSha,
+    context: await resolveLiveBatchStatusContext({
+      repoRoot: request.repoRoot,
+      branch: request.targetBranch
+    })
+  }),
+  readPullRequest: (request, prNumber) => readGitHubMergePullRequest({
+    repoRoot: request.repoRoot,
+    repository: request.repository,
+    prNumber
+  }),
+  build: async (input) => (await import("./merge-batch-RTEEMVDB.js")).buildMergeBatchPullRequest(input),
+  closePullRequest: async (request, prNumber) => {
+    requireCommandOk(
+      await runGitHubCli(
+        [
+          "api",
+          "--hostname",
+          "github.com",
+          "--method",
+          "PATCH",
+          `repos/${request.repository}/pulls/${prNumber}`,
+          "-f",
+          "state=closed"
+        ],
+        { cwd: request.repoRoot }
+      ),
+      `Closing batch PR #${prNumber}`
+    );
+  }
+});
+async function runMergeQueueWorker(input) {
+  const collected = /* @__PURE__ */ new Set();
+  await runMergeQueueWorkerLoop(input, {
+    beforeSelect: async (store, repository, token) => {
+      await resumeApprovedHolds(store, repository, approvalResumeDependencies(store.root));
+      await settleBatchMembers(store, repository, token, mergeBatching(store.root));
+      await formMergeBatch(store, repository, {
+        ...mergeBatching(store.root),
+        collect: async (request) => {
+          if (collected.has(request.id)) return;
+          collected.add(request.id);
+          await new Promise((resolve) => setTimeout(resolve, MERGE_QUEUE_BATCH_COLLECT_MS));
+        }
+      });
+    },
+    processRequest: (request, store) => processMergeRequest(
+      { request, store, stateRoot: store.root },
+      {
+        statusContext: ({ request: candidate, baseSha }) => resolveMergeStatusContext(candidate, baseSha),
+        acquireSlot: ({ request: candidate, checkContinue }) => acquireMergeValidationSlot(candidate, store.root, checkContinue),
+        inspectValidation: ({ request: candidate }) => inspectMergeValidation(candidate, store.root),
+        reuseValidation: ({ request: candidate, baseSha }) => reuseMergeValidation(candidate, baseSha, store.root),
+        validateHead: ({ request: candidate, slot, baseSha, signal, claimHaltOverride }) => validateMergeHead(candidate, slot, store.root, baseSha, signal, claimHaltOverride),
+        assertBatchMembers: (candidate) => assertBatchMembersUnchanged(candidate, store, mergeBatching(store.root)),
+        landingLease: resolveLandingLeaseEnabled(request.repoRoot) ? createMergeQueueLeaseDependencies({
+          repoRoot: request.repoRoot,
+          repository: request.repository,
+          targetBranch: request.targetBranch,
+          stateRoot: store.root
+        }) : void 0
+      }
+    ),
+    closeout: async (request) => {
+      const closeout = await finalizeMergedQueueRequest(request);
+      if (!request.headBranch.startsWith(MERGE_BATCH_BRANCH_PREFIX)) return closeout;
+      const members = await closeMergedBatchMembers({
+        repoRoot: request.repoRoot,
+        repository: request.repository,
+        batchPrNumber: request.prNumber,
+        batchHeadSha: request.acceptedHeadSha
+      }).catch(
+        (error) => `Batch member closeout failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return members ? { ...closeout, message: [closeout.message, members].filter(Boolean).join(" ") } : closeout;
+    }
+  });
+}
+
+export {
+  resolveLiveBatchStatusContext,
+  assertBatchMembersCiClear,
+  assertMergeAdmissiblePullRequest,
+  submitMergeRequest,
+  cancelMergeRequest,
+  inspectMergeQueue,
+  reconcileMergeQueue,
+  mergeBatching,
+  runMergeQueueWorker
+};
+//# sourceMappingURL=chunk-XZRS7I7W.js.map