@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-SVJM3LJA.js

@@ -0,0 +1,27 @@
+import {
+  createCleanChildEnv
+} from "./chunk-WGQAXLNA.js";
+import {
+  selectVerificationToolchainEnv
+} from "./chunk-XSJTIFUY.js";
+
+// src/core/ci/local-ci-child-env.ts
+function createLocalCiDetachedChildEnv(overrides = {}) {
+  const env = createCleanChildEnv({ ...selectVerificationToolchainEnv(process.env), ...overrides });
+  const ghToken = process.env.GH_TOKEN;
+  const githubToken = process.env.GITHUB_TOKEN;
+  if (typeof ghToken === "string" && ghToken.length > 0) {
+    env.GH_TOKEN = ghToken;
+  }
+  if (typeof githubToken === "string" && githubToken.length > 0) {
+    env.GITHUB_TOKEN = githubToken;
+  }
+  delete env.BUILD_LOCAL_CI_APPROVE_ENTRYPOINT_SHA;
+  delete env.BUILD_LOCAL_CI_OVERRIDE_HALT;
+  return env;
+}
+
+export {
+  createLocalCiDetachedChildEnv
+};
+//# sourceMappingURL=chunk-SVJM3LJA.js.map

package/dist/chunk-SVUNZOPG.js

@@ -0,0 +1,129 @@
+// src/core/config/judge-scoring.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { z } from "zod";
+var JudgeTierSchema = z.object({
+  thinkingBudgetTokens: z.number().int().min(0).optional(),
+  requireThinking: z.boolean().optional()
+});
+var JudgeTiersSchema = z.object({
+  ai: JudgeTierSchema,
+  multiLens: JudgeTierSchema
+});
+var JudgeScoringSchema = z.object({
+  tiers: JudgeTiersSchema,
+  defaultJudgeModels: z.enum(["auto", "claude", "codex"]).default("auto"),
+  defaults: z.object({
+    criterionFallback: z.number(),
+    exitCodeMissing: z.number(),
+    displayFallback: z.number()
+  }),
+  confidence: z.object({
+    default: z.number().min(0).max(1),
+    high: z.number().min(0).max(1)
+  }),
+  timeouts: z.object({
+    aiEvaluation: z.number().int().positive(),
+    linterPerFile: z.number().int().positive()
+  }),
+  caps: z.object({
+    planning: z.number(),
+    didNothing: z.number(),
+    patchFailed: z.number(),
+    syntaxErrors: z.number(),
+    testsFailed: z.number(),
+    filesOnlyViolation: z.number()
+  }),
+  truncation: z.object({
+    maxLineLength: z.number().int()
+  }),
+  coreLensWeights: z.object({
+    semanticTaskFit: z.number(),
+    functionalCorrectness: z.number(),
+    maintainability: z.number(),
+    changeDiscipline: z.number()
+  }),
+  fcWeights: z.object({
+    testResults: z.number(),
+    buildHealth: z.number(),
+    runtimeIntegrity: z.number()
+  }),
+  thresholds: z.object({
+    applyRate: z.number(),
+    qualityMinimum: z.number(),
+    qualityAcceptable: z.number(),
+    qualityExcellent: z.number()
+  }),
+  harmonicMean: z.object({
+    floor: z.number()
+  }),
+  // Optional: Scope adequacy configuration (deterministic scope-vs-output signal)
+  scopeAdequacy: z.object({
+    rampRange: z.tuple([z.number(), z.number()]).refine(
+      ([start, end]) => end > start,
+      "scopeAdequacy.rampRange[1] must be greater than rampRange[0]"
+    ),
+    maxPenalty: z.object({
+      minimal: z.number().min(0),
+      partial: z.number().min(0)
+    }),
+    minVariantsForRelative: z.number().int().min(1),
+    absoluteThresholds: z.object({
+      minimal: z.number().gt(0),
+      partial: z.number().gt(0),
+      thorough: z.number().gt(0)
+    }),
+    relativeRescueFloor: z.number().min(0).max(1)
+  }).refine(
+    (value) => value.absoluteThresholds.minimal < value.absoluteThresholds.partial && value.absoluteThresholds.partial < value.absoluteThresholds.thorough,
+    "scopeAdequacy.absoluteThresholds must satisfy minimal < partial < thorough"
+  ).optional()
+}).strict();
+function deepFreeze(obj) {
+  Object.freeze(obj);
+  for (const value of Object.values(obj)) {
+    if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+      deepFreeze(value);
+    }
+  }
+  return obj;
+}
+function loadJudgeScoringConfig() {
+  const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+  const candidatePaths = [
+    path.resolve(moduleDir, "judge-scoring.json"),
+    path.resolve(moduleDir, "../src/core/config/judge-scoring.json")
+  ];
+  const failures = [];
+  for (const configPath of candidatePaths) {
+    try {
+      if (!fs.existsSync(configPath)) {
+        failures.push(`${configPath}: file not found`);
+        continue;
+      }
+      const rawConfig = fs.readFileSync(configPath, "utf-8");
+      const parsedConfig = JSON.parse(rawConfig);
+      delete parsedConfig.$schema;
+      const validationResult = JudgeScoringSchema.safeParse(parsedConfig);
+      if (!validationResult.success) {
+        throw new Error(
+          `Invalid judge-scoring.json: ${validationResult.error.flatten().fieldErrors}`
+        );
+      }
+      return validationResult.data;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      failures.push(`${configPath}: ${message}`);
+    }
+  }
+  throw new Error(`Failed to load or parse judge-scoring.json. Tried: ${failures.join(" | ")}`);
+}
+var JUDGE_SCORING_CONFIG = deepFreeze(
+  loadJudgeScoringConfig()
+);
+
+export {
+  JUDGE_SCORING_CONFIG
+};
+//# sourceMappingURL=chunk-SVUNZOPG.js.map

package/dist/chunk-T5XLUYV3.js

@@ -0,0 +1,34 @@
+// src/cli/utils/planning-storage-unavailable.ts
+var PLANNING_STORAGE_UNAVAILABLE_ERROR_NAME = "PlanningStorageUnavailableError";
+var PLANNING_STORAGE_UNAVAILABLE_PREFIX = "planning storage unavailable";
+function planningStorageUnavailableReason(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const carrier = value;
+  if (carrier.name !== PLANNING_STORAGE_UNAVAILABLE_ERROR_NAME && carrier.kind !== "unavailable") {
+    return void 0;
+  }
+  for (const candidate of [carrier.reason, carrier.message]) {
+    if (typeof candidate === "string" && candidate.trim() !== "") return candidate.trim();
+  }
+  return "reason not reported";
+}
+function formatPlanningStorageUnavailable(reason) {
+  return `Error: ${PLANNING_STORAGE_UNAVAILABLE_PREFIX}: ${reason}`;
+}
+function reportPlanningStorageUnavailable(value) {
+  const reason = planningStorageUnavailableReason(value);
+  if (reason === void 0) return false;
+  console.error(formatPlanningStorageUnavailable(reason));
+  return true;
+}
+function reportPlanningCommandError(error) {
+  if (reportPlanningStorageUnavailable(error)) return;
+  console.error(error instanceof Error ? error.message : String(error));
+}
+
+export {
+  planningStorageUnavailableReason,
+  formatPlanningStorageUnavailable,
+  reportPlanningCommandError
+};
+//# sourceMappingURL=chunk-T5XLUYV3.js.map

package/dist/chunk-T7E5JS6N.js

@@ -0,0 +1,57 @@
+// src/utils/env-parse.ts
+var _timeoutWarningGuard = /* @__PURE__ */ new Set();
+function readTimeoutEnvWithAlias(newName, legacyName) {
+  const newVal = process.env[newName];
+  const legacyVal = process.env[legacyName];
+  if (legacyVal !== void 0 && newVal === void 0 && !_timeoutWarningGuard.has(legacyName)) {
+    console.warn(`Warning: ${legacyName} is deprecated; use ${newName}.`);
+    _timeoutWarningGuard.add(legacyName);
+  }
+  return newVal ?? legacyVal;
+}
+function parsePositiveInt(value) {
+  if (value === void 0 || value === null) return void 0;
+  const n = typeof value === "number" ? value : Number.parseInt(String(value), 10);
+  if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) return void 0;
+  return n;
+}
+function parseEnvBoolean(value, fallback) {
+  if (value === void 0) return fallback;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "1" || normalized === "true") return true;
+  if (normalized === "0" || normalized === "false") return false;
+  return fallback;
+}
+function parseCsvList(value) {
+  if (!value) return void 0;
+  const items = value.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+  return items.length > 0 ? items : void 0;
+}
+function getIntEnv(envVar, defaultValue, options) {
+  const raw = process.env[envVar];
+  if (!raw) {
+    return defaultValue;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed)) {
+    return defaultValue;
+  }
+  const allowZero = options?.allowZero ?? false;
+  const allowNegative = options?.allowNegative ?? false;
+  if (!allowZero && parsed === 0) {
+    return defaultValue;
+  }
+  if (!allowNegative && parsed < 0) {
+    return defaultValue;
+  }
+  return parsed;
+}
+
+export {
+  readTimeoutEnvWithAlias,
+  parsePositiveInt,
+  parseEnvBoolean,
+  parseCsvList,
+  getIntEnv
+};
+//# sourceMappingURL=chunk-T7E5JS6N.js.map

package/dist/chunk-TA3N5MMO.js

@@ -0,0 +1,450 @@
+import {
+  RepositorySchema,
+  repositoryFromGitHubRemoteUrl
+} from "./chunk-BDPYFAB4.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+
+// src/core/ci/merge-batch-members.ts
+import { z as z3 } from "zod";
+
+// src/core/ci/github-merge.ts
+import { execa } from "execa";
+import { z as z2 } from "zod";
+
+// src/core/ci/github-merge-tree.ts
+import { z } from "zod";
+var ShaSchema = z.string().regex(/^[a-f0-9]{40}$/i).transform((sha) => sha.toLowerCase());
+async function verifyGitHubMechanicalMerge(input, dependencies = {}) {
+  const parsed = z.object({
+    repoRoot: z.string().min(1),
+    parentSha: ShaSchema,
+    baseSha: ShaSchema,
+    preparedSha: ShaSchema
+  }).parse(input);
+  const git = dependencies.git ?? execGit;
+  const metadata = await git(["show", "-s", "--format=%P%n%T", parsed.preparedSha], {
+    cwd: parsed.repoRoot,
+    timeoutMs: 6e4,
+    env: { GIT_NO_REPLACE_OBJECTS: "1" }
+  });
+  if (metadata.exitCode !== 0) {
+    throw new Error(
+      `Unable to inspect prepared merge commit: ${metadata.stderr || metadata.stdout}`
+    );
+  }
+  const lines = metadata.stdout.trim().split(/\r?\n/);
+  if (lines.length !== 2) throw new Error("Git returned malformed prepared-commit metadata.");
+  const parents = z.array(ShaSchema).parse(lines[0]?.split(" "));
+  const actualTree = ShaSchema.parse(lines[1]);
+  if (parents.length !== 2 || parents[0] !== parsed.parentSha || parents[1] !== parsed.baseSha) {
+    return { verified: false, reason: "parent_mismatch" };
+  }
+  const merged = await git(["merge-tree", "--write-tree", parsed.parentSha, parsed.baseSha], {
+    cwd: parsed.repoRoot,
+    timeoutMs: 6e4,
+    env: { GIT_NO_REPLACE_OBJECTS: "1" }
+  });
+  if (merged.exitCode === 1) return { verified: false, reason: "conflict" };
+  if (merged.exitCode !== 0) {
+    throw new Error(`Unable to compute mechanical merge tree: ${merged.stderr || merged.stdout}`);
+  }
+  const expectedTree = ShaSchema.parse(merged.stdout.trim().split(/\r?\n/, 1)[0]);
+  return actualTree === expectedTree ? { verified: true, treeSha: expectedTree } : { verified: false, reason: "tree_mismatch" };
+}
+
+// src/core/ci/github-merge.ts
+var ShaSchema2 = z2.string().regex(/^[a-f0-9]{40}$/i).transform((sha) => sha.toLowerCase());
+var MethodSchema = z2.enum(["merge", "squash", "rebase"]);
+var PrInputSchema = z2.object({
+  repoRoot: z2.string().min(1),
+  repository: RepositorySchema,
+  prNumber: z2.number().int().positive()
+});
+var WriteInputSchema = PrInputSchema.extend({ expectedHeadSha: ShaSchema2 });
+var CheckSchema = z2.object({
+  name: z2.string().min(1),
+  state: z2.string().min(1),
+  bucket: z2.enum(["pass", "fail", "pending", "skipping", "cancel"]),
+  workflow: z2.string(),
+  link: z2.string()
+});
+var GitHubMergeOperationError = class extends Error {
+  constructor(message, outcome, statusCode) {
+    super(message);
+    this.outcome = outcome;
+    this.statusCode = statusCode;
+    this.name = "GitHubMergeOperationError";
+  }
+  outcome;
+  statusCode;
+};
+var defaultGh = async (args, options) => {
+  const result = await execa("gh", args, {
+    cwd: options.cwd,
+    input: options.input,
+    reject: false,
+    timeout: 6e4,
+    stdio: "pipe"
+  });
+  return {
+    exitCode: result.timedOut || result.signal ? null : result.exitCode ?? null,
+    stdout: result.stdout,
+    stderr: result.stderr
+  };
+};
+var runGitHubCli = defaultGh;
+function detail(result) {
+  return (result.stderr || result.stdout).trim().split(/\r?\n/, 1)[0] || `GitHub CLI exited ${result.exitCode ?? "without a result"}`;
+}
+function apiArgs(method, endpoint) {
+  return ["api", "--hostname", "github.com", "--method", method, endpoint];
+}
+async function readJson(args, options, dependencies) {
+  const result = await (dependencies.gh ?? defaultGh)(args, options);
+  if (result.exitCode !== 0) throw new Error(`GitHub CLI failed: ${detail(result)}`);
+  return JSON.parse(result.stdout);
+}
+var RepositoryMetadataSchema = z2.object({
+  data: z2.object({
+    repository: z2.object({
+      nameWithOwner: RepositorySchema,
+      defaultBranchRef: z2.object({ name: z2.string().min(1) }),
+      mergeCommitAllowed: z2.boolean(),
+      squashMergeAllowed: z2.boolean(),
+      rebaseMergeAllowed: z2.boolean(),
+      viewerDefaultMergeMethod: z2.enum(["MERGE", "SQUASH", "REBASE"]).nullable()
+    })
+  })
+});
+async function readGitHubMergeRepository(input, dependencies = {}) {
+  let repository = input.repository;
+  if (repository === void 0) {
+    const remote = await (dependencies.git ?? execGit)(["remote", "get-url", "origin"], {
+      cwd: input.repoRoot
+    });
+    repository = remote.exitCode === 0 ? repositoryFromGitHubRemoteUrl(remote.stdout) ?? void 0 : void 0;
+    if (!repository) throw new Error("Origin is not a supported GitHub repository.");
+  }
+  repository = RepositorySchema.parse(repository);
+  const [owner, name] = repository.split("/");
+  const payload = await readJson(
+    ["api", "--hostname", "github.com", "graphql", "--input", "-"],
+    {
+      cwd: input.repoRoot,
+      input: JSON.stringify({
+        query: `query($owner: String!, $name: String!) {
+          repository(owner: $owner, name: $name) {
+            nameWithOwner defaultBranchRef { name }
+            mergeCommitAllowed squashMergeAllowed rebaseMergeAllowed viewerDefaultMergeMethod
+          }
+        }`,
+        variables: { owner, name }
+      })
+    },
+    dependencies
+  );
+  const metadata = RepositoryMetadataSchema.parse(payload).data.repository;
+  if (metadata.nameWithOwner.toLowerCase() !== repository.toLowerCase()) {
+    throw new Error("GitHub repository identity changed.");
+  }
+  const allowedMergeMethods = [];
+  if (metadata.mergeCommitAllowed) allowedMergeMethods.push("merge");
+  if (metadata.squashMergeAllowed) allowedMergeMethods.push("squash");
+  if (metadata.rebaseMergeAllowed) allowedMergeMethods.push("rebase");
+  return {
+    repository: metadata.nameWithOwner,
+    defaultBranch: metadata.defaultBranchRef.name,
+    allowedMergeMethods,
+    preferredMergeMethod: metadata.viewerDefaultMergeMethod === null ? null : MethodSchema.parse(metadata.viewerDefaultMergeMethod.toLowerCase())
+  };
+}
+function resolveGitHubMergeMethod(repository) {
+  const { preferredMergeMethod, allowedMergeMethods } = repository;
+  if (preferredMergeMethod && allowedMergeMethods.includes(preferredMergeMethod)) {
+    return preferredMergeMethod;
+  }
+  if (allowedMergeMethods.length === 1 && allowedMergeMethods[0]) return allowedMergeMethods[0];
+  throw new Error("No unambiguous allowed GitHub merge method is available.");
+}
+var RefSchema = z2.object({
+  sha: ShaSchema2,
+  ref: z2.string().min(1),
+  repo: z2.object({ full_name: RepositorySchema }).nullable()
+});
+var PullRequestSchema = z2.object({
+  number: z2.number().int().positive(),
+  state: z2.enum(["open", "closed"]),
+  draft: z2.boolean(),
+  merged: z2.boolean(),
+  merge_commit_sha: ShaSchema2.nullable(),
+  auto_merge: z2.object({ merge_method: MethodSchema }).nullable(),
+  mergeable: z2.boolean().nullable(),
+  mergeable_state: z2.string().min(1),
+  head: RefSchema,
+  base: RefSchema
+});
+async function readGitHubMergePullRequest(input, dependencies = {}) {
+  const parsed = PrInputSchema.parse(input);
+  const pr = PullRequestSchema.parse(
+    await readJson(
+      apiArgs("GET", `repos/${parsed.repository}/pulls/${parsed.prNumber}`),
+      { cwd: parsed.repoRoot },
+      dependencies
+    )
+  );
+  if (pr.number !== parsed.prNumber || pr.base.repo?.full_name.toLowerCase() !== parsed.repository.toLowerCase()) {
+    throw new Error("GitHub pull request identity changed.");
+  }
+  if (pr.merged && (pr.state !== "closed" || !pr.merge_commit_sha)) {
+    throw new Error("GitHub returned inconsistent merged pull request evidence.");
+  }
+  return {
+    repository: pr.base.repo.full_name,
+    prNumber: pr.number,
+    state: pr.merged ? "merged" : pr.state,
+    draft: pr.draft,
+    headSha: pr.head.sha,
+    headBranch: pr.head.ref,
+    headRepository: pr.head.repo?.full_name ?? null,
+    baseSha: pr.base.sha,
+    baseBranch: pr.base.ref,
+    autoMergeEnabled: pr.auto_merge !== null,
+    mergeable: pr.mergeable,
+    mergeStateStatus: pr.mergeable_state,
+    // Before merging this field is GitHub's speculative test-merge commit.
+    mergeCommit: pr.merged ? pr.merge_commit_sha : null
+  };
+}
+async function readGitHubRequiredChecks(input, dependencies = {}) {
+  const parsed = WriteInputSchema.parse(input);
+  const assertHead = async () => {
+    const pr = await readGitHubMergePullRequest(parsed, dependencies);
+    if (pr.headSha !== parsed.expectedHeadSha) {
+      throw new Error("GitHub pull request head changed while reading required checks.");
+    }
+  };
+  await assertHead();
+  const result = await (dependencies.gh ?? defaultGh)(
+    [
+      "pr",
+      "checks",
+      String(parsed.prNumber),
+      "--repo",
+      `github.com/${parsed.repository}`,
+      "--required",
+      "--json",
+      "name,state,bucket,workflow,link"
+    ],
+    { cwd: parsed.repoRoot }
+  );
+  let checks;
+  const noRequired = result.exitCode === 1 && /^no required checks reported on the '[^\r\n]+' branch$/.test(
+    (result.stderr || result.stdout).trim()
+  );
+  if (noRequired) {
+    checks = [];
+  } else {
+    if (![0, 1, 8].includes(result.exitCode ?? -1) || !result.stdout.trim()) {
+      throw new Error(`Unable to read required checks: ${detail(result)}`);
+    }
+    checks = z2.array(CheckSchema).parse(JSON.parse(result.stdout));
+    if (result.exitCode !== 0 && checks.length === 0) {
+      throw new Error(`Unable to read required checks: ${detail(result)}`);
+    }
+  }
+  await assertHead();
+  return {
+    headSha: parsed.expectedHeadSha,
+    checks,
+    state: checks.some((check) => check.bucket === "fail" || check.bucket === "cancel") ? "fail" : checks.some((check) => check.bucket === "pending") ? "pending" : "pass"
+  };
+}
+async function writeJson(input, schema, dependencies) {
+  try {
+    const result = await (dependencies.gh ?? defaultGh)(
+      [...apiArgs("PUT", input.endpoint), "--input", "-"],
+      { cwd: input.repoRoot, input: JSON.stringify(input.payload) }
+    );
+    if (result.exitCode !== 0) {
+      const match = /\(HTTP (\d{3})\)/.exec(result.stderr);
+      const statusCode = match ? Number(match[1]) : void 0;
+      const rejected = result.exitCode !== null && statusCode !== void 0 && statusCode >= 400 && statusCode < 500 && statusCode !== 408;
+      throw new GitHubMergeOperationError(
+        detail(result),
+        rejected ? "rejected" : "unknown",
+        statusCode
+      );
+    }
+    return schema.parse(JSON.parse(result.stdout));
+  } catch (error) {
+    if (error instanceof GitHubMergeOperationError) throw error;
+    throw new GitHubMergeOperationError(
+      `GitHub write outcome is unknown: ${error instanceof Error ? error.message : String(error)}`,
+      "unknown"
+    );
+  }
+}
+async function updateGitHubMergeBranch(input, dependencies = {}) {
+  const parsed = WriteInputSchema.parse(input);
+  await writeJson(
+    {
+      repoRoot: parsed.repoRoot,
+      endpoint: `repos/${parsed.repository}/pulls/${parsed.prNumber}/update-branch`,
+      payload: { expected_head_sha: parsed.expectedHeadSha }
+    },
+    z2.object({ message: z2.string().min(1), url: z2.string().url() }),
+    dependencies
+  );
+  return { accepted: true };
+}
+async function mergeGitHubPullRequestImmediately(input, dependencies = {}) {
+  const parsed = WriteInputSchema.extend({ method: MethodSchema }).parse(input);
+  const response = await writeJson(
+    {
+      repoRoot: parsed.repoRoot,
+      endpoint: `repos/${parsed.repository}/pulls/${parsed.prNumber}/merge`,
+      payload: { sha: parsed.expectedHeadSha, merge_method: parsed.method }
+    },
+    z2.discriminatedUnion("merged", [
+      z2.object({ merged: z2.literal(true), sha: ShaSchema2, message: z2.string() }),
+      z2.object({ merged: z2.literal(false), message: z2.string() })
+    ]),
+    dependencies
+  );
+  return response.merged ? { merged: true, mergeCommit: response.sha, message: response.message } : { merged: false, message: response.message };
+}
+async function fetchGitHubMergeObjects(input, dependencies = {}) {
+  const parsed = PrInputSchema.extend({
+    headSha: ShaSchema2,
+    baseSha: ShaSchema2,
+    baseBranch: z2.string().min(1)
+  }).parse(input);
+  const git = dependencies.git ?? execGit;
+  const remote = await git(["remote", "get-url", "origin"], { cwd: parsed.repoRoot });
+  if (remote.exitCode !== 0 || repositoryFromGitHubRemoteUrl(remote.stdout)?.toLowerCase() !== parsed.repository.toLowerCase()) {
+    throw new Error("Origin remote does not match the admitted GitHub repository.");
+  }
+  const run = async (args) => {
+    const result = await git(args, { cwd: parsed.repoRoot, timeoutMs: 6e4 });
+    if (result.exitCode !== 0) throw new Error(`Git object fetch failed: ${detail(result)}`);
+  };
+  await run(["check-ref-format", `refs/heads/${parsed.baseBranch}`]);
+  await run([
+    "fetch",
+    "--no-tags",
+    "--no-write-fetch-head",
+    "--refmap=",
+    "--no-recurse-submodules",
+    "origin",
+    `refs/pull/${parsed.prNumber}/head`,
+    `refs/heads/${parsed.baseBranch}`,
+    parsed.headSha,
+    parsed.baseSha
+  ]);
+  for (const sha of /* @__PURE__ */ new Set([parsed.headSha, parsed.baseSha])) {
+    await run(["cat-file", "-e", `${sha}^{commit}`]);
+  }
+}
+
+// src/core/ci/merge-batch-members.ts
+var MergeBatchMemberSchema = z3.object({
+  prNumber: z3.number().int().positive(),
+  reviewedSha: z3.string().regex(/^[a-f0-9]{40}$/i).transform((value) => value.toLowerCase())
+});
+var MEMBERS_MARKER = /<!-- build-batch-members: ([0-9a-f:,]+) -->/;
+var MERGE_BATCH_BRANCH_PREFIX = "build-batch/";
+function parseMergeBatchMember(value) {
+  const match = /^#?(\d+):([0-9a-fA-F]{40})$/.exec(value.trim());
+  if (!match) throw new Error(`Expected <pr>:<full-reviewed-sha>, got "${value}".`);
+  return { prNumber: Number(match[1]), reviewedSha: match[2].toLowerCase() };
+}
+function formatMergeBatchMarker(members) {
+  return `<!-- build-batch-members: ${members.map((m) => `${m.prNumber}:${m.reviewedSha}`).join(",")} -->`;
+}
+function readMergeBatchMembers(body) {
+  const match = MEMBERS_MARKER.exec(body ?? "");
+  if (!match) return [];
+  return match[1].split(",").map((entry) => parseMergeBatchMember(entry));
+}
+function requireCommandOk(result, action) {
+  if (result.exitCode !== 0) {
+    const detail2 = (result.stderr || result.stdout).trim().split(/\r?\n/, 1)[0];
+    throw new Error(`${action} failed${detail2 ? `: ${detail2}` : "."}`);
+  }
+  return result.stdout.trim();
+}
+async function closeMergedBatchMembers(input, dependencies = {}) {
+  const git = dependencies.git ?? execGit;
+  const gh = dependencies.gh ?? runGitHubCli;
+  const api = (method, endpoint, fields = []) => gh(["api", "--hostname", "github.com", "--method", method, endpoint, ...fields], {
+    cwd: input.repoRoot
+  });
+  const pr = JSON.parse(
+    requireCommandOk(
+      await api("GET", `repos/${input.repository}/pulls/${input.batchPrNumber}`),
+      "Reading the batch PR"
+    )
+  );
+  const members = readMergeBatchMembers(pr.body).map(
+    (entry) => MergeBatchMemberSchema.parse(entry)
+  );
+  if (members.length === 0) {
+    return `Batch #${input.batchPrNumber} has no member list in its PR body; close its member PRs by hand.`;
+  }
+  const closed = [];
+  const open = [];
+  for (const member of members) {
+    const contained = await git(
+      ["merge-base", "--is-ancestor", member.reviewedSha, input.batchHeadSha],
+      { cwd: input.repoRoot }
+    );
+    const current = JSON.parse(
+      (await api("GET", `repos/${input.repository}/pulls/${member.prNumber}`)).stdout || "{}"
+    );
+    if (contained.exitCode !== 0 || current.head?.sha?.toLowerCase() !== member.reviewedSha) {
+      open.push(member.prNumber);
+      continue;
+    }
+    const comment = await api(
+      "POST",
+      `repos/${input.repository}/issues/${member.prNumber}/comments`,
+      ["-f", `body=Landed in batch #${input.batchPrNumber}.`]
+    );
+    const close = await api("PATCH", `repos/${input.repository}/pulls/${member.prNumber}`, [
+      "-f",
+      "state=closed"
+    ]);
+    if (comment.exitCode === 0 && close.exitCode === 0) closed.push(member.prNumber);
+    else open.push(member.prNumber);
+  }
+  const list = (numbers) => numbers.map((n) => `#${n}`).join(", ");
+  return [
+    `Batch #${input.batchPrNumber} closed member PRs ${list(closed) || "none"}.`,
+    ...open.length > 0 ? [
+      `Left open (not in the batch, moved past its reviewed head, or not closed): ${list(open)}.`
+    ] : []
+  ].join(" ");
+}
+
+export {
+  verifyGitHubMechanicalMerge,
+  GitHubMergeOperationError,
+  runGitHubCli,
+  readGitHubMergeRepository,
+  resolveGitHubMergeMethod,
+  readGitHubMergePullRequest,
+  readGitHubRequiredChecks,
+  updateGitHubMergeBranch,
+  mergeGitHubPullRequestImmediately,
+  fetchGitHubMergeObjects,
+  MergeBatchMemberSchema,
+  MERGE_BATCH_BRANCH_PREFIX,
+  parseMergeBatchMember,
+  formatMergeBatchMarker,
+  readMergeBatchMembers,
+  requireCommandOk,
+  closeMergedBatchMembers
+};
+//# sourceMappingURL=chunk-TA3N5MMO.js.map