@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-3C7WBIVK.js

@@ -0,0 +1,1016 @@
+import {
+  detectHostConcurrencyBudget
+} from "./chunk-BZRLSZNV.js";
+import {
+  runDeterministicTestGateWithArtifacts,
+  runLintOnDiffWithArtifacts
+} from "./chunk-JOSK6GEU.js";
+import {
+  GATE_OUTPUT_TAIL_LINES,
+  runTypecheckWithArtifacts
+} from "./chunk-IWBHRSG7.js";
+import {
+  copyConfiguredEnvFilesToWorktree,
+  prepareWorktreeDependencies
+} from "./chunk-BIUV23HH.js";
+import {
+  pruneGitWorktreeEntries
+} from "./chunk-33IGPPUI.js";
+import {
+  atomicWriteJson
+} from "./chunk-RFDVSI4N.js";
+import {
+  createLogger
+} from "./chunk-3OPP2OZB.js";
+import {
+  parseVerificationErrorsForChannel
+} from "./chunk-PXKERBKX.js";
+import {
+  mkBuildTempDir
+} from "./chunk-D6WTZMZB.js";
+import {
+  parseFailureOutput,
+  resolveVerificationChannelScope,
+  selectScopedTestCommands
+} from "./chunk-AHU3FKPA.js";
+import {
+  createTypeScriptLocatedErrorPattern,
+  extractBiomeJson,
+  readBiomeDiagnostics
+} from "./chunk-TUQMMFEQ.js";
+import {
+  describeVerificationCommand
+} from "./chunk-EPAMVGI3.js";
+import {
+  safeRmDir
+} from "./chunk-ALDTFNZ3.js";
+import {
+  resolveVerifyCommandTimeoutMs
+} from "./chunk-2VUEDIUM.js";
+import {
+  tailLines
+} from "./chunk-2VLJUXJU.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import {
+  processIsAlive
+} from "./chunk-MT2WAIR3.js";
+import {
+  getStateDir
+} from "./chunk-56WPYDJH.js";
+import {
+  BUILD_VALIDATION_SLOTS,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/verification/baseline-store.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir2, readFile as readFile2, rm } from "fs/promises";
+import { dirname as dirname2, join } from "path";
+import lockfile from "proper-lockfile";
+
+// src/core/git/scratch-worktree.ts
+import * as path from "path";
+var SCRATCH_WORKTREE_ADD_TIMEOUT_MS = 6e4;
+var SCRATCH_WORKTREE_REMOVE_TIMEOUT_MS = 6e4;
+async function removeScratchWorktree(options) {
+  const { repoRoot, worktreePath, timeoutMs = SCRATCH_WORKTREE_REMOVE_TIMEOUT_MS } = options;
+  await execGit(["worktree", "remove", "--force", worktreePath], {
+    cwd: repoRoot,
+    timeoutMs
+  }).catch(() => void 0);
+  await safeRmDir(worktreePath, {
+    protectedPaths: [repoRoot],
+    managedRoots: [path.dirname(worktreePath)]
+  }).catch(() => void 0);
+  await pruneGitWorktreeEntries({ cwd: repoRoot, paths: [worktreePath] }).catch(() => void 0);
+}
+async function addScratchWorktree(options) {
+  const { repoRoot, worktreePath, ref, timeoutMs = SCRATCH_WORKTREE_ADD_TIMEOUT_MS } = options;
+  let failure;
+  try {
+    const added = await execGit(["worktree", "add", "--detach", worktreePath, ref], {
+      cwd: repoRoot,
+      timeoutMs
+    });
+    if (added.exitCode === 0) return { ok: true };
+    failure = {
+      exitCode: added.exitCode,
+      detail: added.stderr.trim() || added.stdout.trim() || "no output"
+    };
+  } catch (error) {
+    failure = {
+      exitCode: null,
+      detail: error instanceof Error ? error.message : String(error)
+    };
+  }
+  await removeScratchWorktree({ repoRoot, worktreePath });
+  return { ok: false, ...failure };
+}
+
+// src/core/verification/validation-slots.ts
+import { randomUUID } from "crypto";
+import * as fs from "fs/promises";
+import path2 from "path";
+var logger = createLogger("ValidationSlots");
+var STALE_SLOT_MAX_AGE_MS = 30 * 60 * 1e3;
+var SLOT_HARD_CEILING_MS = 2 * 60 * 60 * 1e3;
+var DEFAULT_MAX_WAIT_MS = 5 * 60 * 1e3;
+var DEFAULT_POLL_INTERVAL_MS = 250;
+var POLL_JITTER_MS = 750;
+function defaultValidationSlotDir() {
+  return path2.join(getStateDir(), "validation-slots");
+}
+function isPidAlive(pid) {
+  return Number.isInteger(pid) && pid > 0 && processIsAlive(pid);
+}
+async function listSlotFiles(slotDir) {
+  const entries = await fs.readdir(slotDir);
+  return entries.filter((name) => name.endsWith(".slot"));
+}
+async function cleanupStaleSlots(slotDir, now) {
+  const names = await listSlotFiles(slotDir);
+  for (const name of names) {
+    const filePath = path2.join(slotDir, name);
+    try {
+      const stat2 = await fs.stat(filePath);
+      const ageMs = now - stat2.mtimeMs;
+      if (ageMs > SLOT_HARD_CEILING_MS) {
+        await fs.unlink(filePath);
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(await fs.readFile(filePath, "utf8"));
+      } catch {
+        if (ageMs > STALE_SLOT_MAX_AGE_MS) await fs.unlink(filePath);
+        continue;
+      }
+      if (!isPidAlive(parsed.pid)) {
+        await fs.unlink(filePath);
+      }
+    } catch {
+    }
+  }
+}
+async function slotRank(slotDir, ownName) {
+  const names = await listSlotFiles(slotDir);
+  const ranked = [];
+  for (const name of names) {
+    try {
+      const stat2 = await fs.stat(path2.join(slotDir, name));
+      ranked.push({ name, mtimeMs: stat2.mtimeMs });
+    } catch {
+    }
+  }
+  ranked.sort((a, b) => a.mtimeMs - b.mtimeMs || a.name.localeCompare(b.name));
+  return ranked.findIndex((entry) => entry.name === ownName);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var degradedWarned = false;
+function warnDegraded(label, reason, context) {
+  if (degradedWarned && reason === "slot-dir-unavailable") return;
+  if (reason === "slot-dir-unavailable") degradedWarned = true;
+  logger.warn(`Validation slot degraded (${reason}); proceeding unpaced`, { label, ...context });
+}
+function resolveHostLimit(explicit) {
+  if (explicit !== void 0) return Math.max(1, Math.floor(explicit));
+  const env = readEnv(BUILD_VALIDATION_SLOTS).value;
+  if (env !== void 0 && Number.isFinite(env)) {
+    if (env <= 0) return null;
+    return Math.floor(env);
+  }
+  return Math.max(1, detectHostConcurrencyBudget().validationSlots);
+}
+async function acquireHostValidationSlot(label, options = {}) {
+  const slotDir = options.slotDir ?? defaultValidationSlotDir();
+  const hostLimit = resolveHostLimit(options.hostLimit);
+  if (hostLimit === null) {
+    return { degraded: false, release: async () => {
+    } };
+  }
+  const maxWaitMs = options.maxWaitMs ?? DEFAULT_MAX_WAIT_MS;
+  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const ownName = `${process.pid}-${randomUUID()}.slot`;
+  const ownPath = path2.join(slotDir, ownName);
+  const deadline = Date.now() + maxWaitMs;
+  try {
+    await fs.mkdir(slotDir, { recursive: true });
+  } catch (error) {
+    warnDegraded(label, "slot-dir-unavailable", { slotDir, error: String(error) });
+    return { degraded: true, release: async () => {
+    } };
+  }
+  let waitedLogged = false;
+  for (; ; ) {
+    try {
+      await cleanupStaleSlots(slotDir, Date.now());
+      const occupied = (await listSlotFiles(slotDir)).length;
+      if (occupied < hostLimit) {
+        const content = {
+          pid: process.pid,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          label
+        };
+        await fs.writeFile(ownPath, JSON.stringify(content), { flag: "wx" });
+        const rank = await slotRank(slotDir, ownName);
+        if (rank >= 0 && rank < hostLimit) {
+          return {
+            degraded: false,
+            release: async () => {
+              try {
+                await fs.unlink(ownPath);
+              } catch {
+              }
+            }
+          };
+        }
+        await fs.unlink(ownPath).catch(() => {
+        });
+      }
+    } catch (error) {
+      warnDegraded(label, "slot-dir-unavailable", { slotDir, error: String(error) });
+      return { degraded: true, release: async () => {
+      } };
+    }
+    if (Date.now() >= deadline) {
+      warnDegraded(label, "wait-deadline", { slotDir, hostLimit, maxWaitMs });
+      return { degraded: true, release: async () => {
+      } };
+    }
+    if (!waitedLogged) {
+      waitedLogged = true;
+      logger.info("Waiting for a host validation slot", { label, hostLimit });
+    }
+    await sleep(pollIntervalMs + Math.floor(Math.random() * POLL_JITTER_MS));
+  }
+}
+async function withValidationSlot(label, fn, options = {}) {
+  const lease = await acquireHostValidationSlot(label, options);
+  try {
+    return await fn();
+  } finally {
+    await lease.release();
+  }
+}
+
+// src/core/verification/baseline-capture.ts
+var BASELINE_SCHEMA_VERSION = 7;
+var DEFAULT_OPTIONS = {
+  changedSinceRef: "",
+  skipTests: false,
+  skipLint: false,
+  outputTailLines: GATE_OUTPUT_TAIL_LINES,
+  changedFiles: []
+};
+function resolveGateExitCode(rawExitCode, okHint, didNotRun = false) {
+  if (didNotRun) return 0;
+  if (typeof rawExitCode === "number") return rawExitCode;
+  if (okHint === true) return 0;
+  return 1;
+}
+function channelCommands(channel) {
+  if (Array.isArray(channel.commands) && channel.commands.length > 0) return channel.commands;
+  if (channel.command?.trim()) return [channel.command];
+  return [];
+}
+function commandDominanceRank(result) {
+  const status = result.status;
+  if (status === "timeout" || result.exitCode === 124) return 1;
+  if (status === "unavailable") return 2;
+  if (status === "skipped" || status === "passed" || status === "not_run" || result.exitCode === 0) {
+    return 3;
+  }
+  return 0;
+}
+function selectDominantCommandResult(results) {
+  if (results.length === 0) return void 0;
+  let dominant = results[0];
+  let best = commandDominanceRank(dominant);
+  for (let i = 1; i < results.length; i++) {
+    const candidate = results[i];
+    const rank = commandDominanceRank(candidate);
+    if (rank < best) {
+      dominant = candidate;
+      best = rank;
+    }
+  }
+  return dominant;
+}
+function normalizeTypeError(line) {
+  const match = createTypeScriptLocatedErrorPattern("parenthesized", {
+    message: "code-prefix",
+    locationWhitespace: "optional"
+  }).exec(line);
+  if (match) {
+    return `${match[1]}:${match[2]}:${match[3]}:${match[4]}`;
+  }
+  const altMatch = createTypeScriptLocatedErrorPattern("colon", {
+    message: "code-prefix",
+    locationWhitespace: "optional"
+  }).exec(line);
+  if (altMatch) {
+    return `${altMatch[1]}:${altMatch[2]}:${altMatch[3]}:${altMatch[4]}`;
+  }
+  return null;
+}
+function extractTypeErrors(output) {
+  const errors = [];
+  for (const line of output.split(/\r?\n/)) {
+    const normalized = normalizeTypeError(line);
+    if (normalized) {
+      errors.push(normalized);
+    }
+  }
+  return errors.slice(0, 100);
+}
+function normalizeLintError(line) {
+  const match = /^(.+?):(\d+):(\d+)\s+(?:error|warning)\s+.+?\s+(\S+)\s*$/.exec(line);
+  if (match) {
+    return `${match[1]}:${match[2]}:${match[3]}:${match[4]}`;
+  }
+  return null;
+}
+function extractLintErrors(output) {
+  const errors = [];
+  for (const line of output.split(/\r?\n/)) {
+    const normalized = normalizeLintError(line);
+    if (normalized) {
+      errors.push(normalized);
+    }
+  }
+  return errors.slice(0, 100);
+}
+function extractBiomeLintSignatures(outputTail) {
+  const raw = String(outputTail ?? "").trim();
+  if (!raw) return [];
+  const out = /* @__PURE__ */ new Set();
+  const extracted = extractBiomeJson(raw);
+  if (extracted) {
+    for (const diag of readBiomeDiagnostics(extracted.parsed)) {
+      const category = diag.category ?? diag.severity ?? "issue";
+      out.add(`${diag.file}:${category}${diag.line ? `:${diag.line}` : ""}`);
+    }
+  }
+  if (out.size > 0) return Array.from(out).slice(0, 200);
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    const eslintMatch = /^(.+?):(\d+):(\d+)\s+(?:error|warning)\s+.+?\s+(\S+)\s*$/.exec(trimmed);
+    if (eslintMatch) {
+      out.add(`${eslintMatch[1]}:${eslintMatch[2]}:${eslintMatch[3]}:${eslintMatch[4]}`);
+      continue;
+    }
+    const biomePrettyMatch = /^(.+?):(\d+):(\d+)\s+([a-z]+\/\S+)(?:\s|$)/.exec(trimmed);
+    if (biomePrettyMatch) {
+      out.add(
+        `${biomePrettyMatch[1]}:${biomePrettyMatch[2]}:${biomePrettyMatch[3]}:${biomePrettyMatch[4]}`
+      );
+    }
+  }
+  return Array.from(out).slice(0, 200);
+}
+function captureAvailability(captures) {
+  if (captures.some((capture) => capture.status === "unavailable")) return "unavailable";
+  return captures.every((capture) => capture.status === "skipped") ? "out_of_scope" : "executed";
+}
+function nonExecutionStatus(coverage, exitCode) {
+  if (exitCode === 124) return void 0;
+  if (coverage?.status === "skipped_not_relevant") return "skipped";
+  if (coverage?.status === "skipped_no_command" || coverage?.status === "skipped_tool_unavailable" || coverage?.status === "unverified")
+    return "unavailable";
+  return void 0;
+}
+function toCommandSummary(capture) {
+  return {
+    command: capture.command,
+    language: capture.language,
+    exitCode: capture.exitCode,
+    parsed: capture.parsed,
+    status: capture.status,
+    outputTail: capture.outputTail,
+    ...capture.failedTests ? { failedTests: capture.failedTests } : {},
+    ...capture.testsRun !== void 0 ? {
+      testsRun: capture.testsRun,
+      testsPassed: capture.testsPassed,
+      testsSkipped: capture.testsSkipped
+    } : {}
+  };
+}
+function budgetTimeoutCapture(command) {
+  const language = describeVerificationCommand(command).language;
+  return {
+    command,
+    language,
+    exitCode: 124,
+    parsed: false,
+    outputTail: "timed out (channel budget exhausted)",
+    status: "timeout",
+    durationMs: 0,
+    errors: [],
+    captureError: "Channel budget exhausted before command ran"
+  };
+}
+async function runCommandsSequentially(commands, gateTimeoutMs, runOne) {
+  if (commands.length === 0) {
+    return [await runOne(void 0, gateTimeoutMs)];
+  }
+  let remaining = gateTimeoutMs;
+  const captures = [];
+  for (const command of commands) {
+    if (remaining <= 0) {
+      captures.push(budgetTimeoutCapture(command));
+      continue;
+    }
+    const capture = await runOne(command, remaining);
+    captures.push(capture);
+    remaining = Math.max(0, remaining - Math.max(0, capture.durationMs));
+  }
+  return captures;
+}
+function aggregateBuildCaptures(captures) {
+  const dominant = selectDominantCommandResult(captures) ?? captures[0];
+  const errors = Array.from(new Set(captures.flatMap((c) => c.errors))).slice(0, 100);
+  const captureErrors = captures.map((c) => c.captureError).filter(Boolean);
+  return {
+    result: {
+      exitCode: dominant?.exitCode ?? 0,
+      count: errors.length,
+      errors,
+      signaturesParseable: dominant?.parsed ?? true,
+      // Representative tail only — full per-command tails live in `commands`.
+      outputTail: dominant?.outputTail ?? ""
+    },
+    captureError: captureErrors[0],
+    language: dominant?.language ?? "unknown",
+    parsed: dominant?.parsed ?? true,
+    commands: captures.map(toCommandSummary),
+    availability: captureAvailability(captures)
+  };
+}
+function aggregateLintCaptures(captures) {
+  const dominant = selectDominantCommandResult(captures) ?? captures[0];
+  const errors = Array.from(new Set(captures.flatMap((c) => c.errors))).slice(0, 200);
+  const captureErrors = captures.map((c) => c.captureError).filter(Boolean);
+  return {
+    result: {
+      exitCode: dominant?.exitCode ?? 0,
+      count: errors.length,
+      errors,
+      signaturesParseable: dominant?.parsed ?? true,
+      outputTail: dominant?.outputTail ?? ""
+    },
+    captureError: captureErrors[0],
+    language: dominant?.language ?? "unknown",
+    parsed: dominant?.parsed ?? true,
+    commands: captures.map(toCommandSummary),
+    availability: captureAvailability(captures)
+  };
+}
+function aggregateTestCaptures(captures) {
+  const dominant = selectDominantCommandResult(captures) ?? captures[0];
+  const failedTests = Array.from(new Set(captures.flatMap((c) => c.failedTests ?? [])));
+  const captureErrors = captures.map((c) => c.captureError).filter(Boolean);
+  const comparable = captures.every((capture) => capture.testsRun !== void 0);
+  return {
+    result: {
+      exitCode: dominant?.exitCode ?? 0,
+      passed: comparable ? captures.reduce((sum, capture) => sum + (capture.testsPassed ?? 0), 0) : 0,
+      failed: comparable ? captures.reduce((sum, capture) => sum + (capture.testsFailed ?? 0), 0) : 0,
+      ...comparable ? {
+        run: captures.reduce((sum, capture) => sum + (capture.testsRun ?? 0), 0),
+        skipped: captures.reduce((sum, capture) => sum + (capture.testsSkipped ?? 0), 0)
+      } : {},
+      failedTests,
+      outputTail: dominant?.outputTail ?? ""
+    },
+    captureError: captureErrors[0],
+    language: dominant?.language ?? "unknown",
+    parsed: dominant?.parsed ?? true,
+    commands: captures.map(toCommandSummary),
+    availability: captureAvailability(captures)
+  };
+}
+async function captureTypecheckOnce(worktreePath, timeoutMs, outputTailLines, scopedCommand) {
+  const started = Date.now();
+  const artifact = await runTypecheckWithArtifacts(worktreePath, {
+    timeoutMs,
+    tailLines: Math.max(50, outputTailLines),
+    ...scopedCommand ? { command: scopedCommand } : {}
+  });
+  const output = String(artifact.output ?? artifact.outputTail ?? "");
+  const nonExecution = nonExecutionStatus(artifact.verificationCoverage, artifact.exitCode);
+  const exitCode = resolveGateExitCode(artifact.exitCode, artifact.ok, nonExecution !== void 0);
+  const failed = exitCode !== 0;
+  const language = artifact.language ?? describeVerificationCommand(artifact.command ?? "").language;
+  const parsedResult = parseVerificationErrorsForChannel("build", language, output, failed);
+  const errors = nonExecution ? [] : extractTypeErrors(output);
+  const captureError = nonExecution ? void 0 : exitCode === 124 ? "Typecheck timed out during baseline capture" : (artifact.command ?? "").trim().length === 0 ? "Typecheck command missing during baseline capture" : artifact.exitCode == null && artifact.ok !== true ? "Typecheck command did not exit cleanly during baseline capture (fail-closed)" : void 0;
+  const status = nonExecution ?? (exitCode === 124 ? "timeout" : exitCode === 0 ? "passed" : "failed");
+  return {
+    command: artifact.command ?? scopedCommand ?? "",
+    language,
+    exitCode,
+    parsed: nonExecution ? false : parsedResult.parsed,
+    outputTail: tailLines(output, outputTailLines),
+    status,
+    durationMs: artifact.durationMs ?? Math.max(0, Date.now() - started),
+    errors,
+    captureError
+  };
+}
+async function captureLintOnce(worktreePath, sinceRef, timeoutMs, outputTailLines, scopedCommand) {
+  const started = Date.now();
+  const artifact = await runLintOnDiffWithArtifacts(worktreePath, {
+    baseBranch: sinceRef,
+    timeoutMs,
+    tailLines: Math.max(50, outputTailLines),
+    ...scopedCommand ? { command: scopedCommand } : {}
+  });
+  const outputTail = tailLines(artifact.outputTail, outputTailLines);
+  const nonExecution = nonExecutionStatus(artifact.verificationCoverage, artifact.exitCode);
+  const okHint = artifact.result === null ? void 0 : artifact.exitCode === 0;
+  const exitCode = resolveGateExitCode(artifact.exitCode, okHint, nonExecution !== void 0);
+  const failed = exitCode !== 0;
+  const language = artifact.language ?? describeVerificationCommand(artifact.command ?? "").language;
+  const parsedResult = parseVerificationErrorsForChannel(
+    "lint",
+    language,
+    artifact.outputTail ?? "",
+    failed
+  );
+  const biome = extractBiomeLintSignatures(artifact.outputTail ?? "");
+  const errors = nonExecution ? [] : biome.length > 0 ? biome : extractLintErrors(artifact.outputTail ?? "");
+  const captureError = exitCode === 124 ? "Lint timed out during baseline capture" : failed && artifact.result === null ? "Lint gate returned no parseable result during baseline capture" : void 0;
+  const status = nonExecution ?? (exitCode === 124 ? "timeout" : exitCode === 0 ? "passed" : "failed");
+  return {
+    command: artifact.command ?? scopedCommand ?? "",
+    language,
+    exitCode,
+    parsed: nonExecution ? false : parsedResult.parsed,
+    outputTail,
+    status,
+    durationMs: artifact.durationMs ?? Math.max(0, Date.now() - started),
+    errors,
+    captureError
+  };
+}
+async function captureTestsOnce(worktreePath, sinceRef, timeoutMs, outputTailLines, scopedCommand) {
+  const started = Date.now();
+  const artifact = await runDeterministicTestGateWithArtifacts(worktreePath, {
+    baseRef: sinceRef,
+    timeoutMs,
+    tailLines: Math.max(50, outputTailLines),
+    ...scopedCommand ? { command: scopedCommand } : {}
+  });
+  const status = artifact.status ?? "failed";
+  const ranAndFailed = status === "failed" || status === "error" || status === "timeout";
+  const didNotRun = status === "unavailable" || status === "skipped";
+  const okHint = !ranAndFailed;
+  const exitCode = resolveGateExitCode(artifact.exitCode, okHint, didNotRun);
+  const outputTail = tailLines(artifact.outputTail ?? "", outputTailLines);
+  const language = artifact.language ?? describeVerificationCommand(artifact.command ?? "").language;
+  const parsedResult = parseVerificationErrorsForChannel(
+    "test",
+    language,
+    outputTail,
+    exitCode !== 0,
+    artifact.failingTests ?? []
+  );
+  const parsedCounts = parseFailureOutput(
+    artifact.command ?? scopedCommand ?? "",
+    outputTail,
+    "test"
+  );
+  const suiteFootprint = parsedCounts.parsed ? parsedCounts.suiteFootprint : void 0;
+  const failedCount = suiteFootprint && parsedCounts.errorCount !== null ? parsedCounts.errorCount : void 0;
+  const captureError = status === "timeout" ? "Tests timed out during baseline capture" : status === "error" ? "Tests errored during baseline capture" : ranAndFailed && artifact.exitCode == null ? "Tests reported failure without a clean exit during baseline capture (fail-closed)" : void 0;
+  return {
+    command: artifact.command ?? scopedCommand ?? "",
+    language,
+    exitCode,
+    parsed: didNotRun ? false : parsedResult.parsed,
+    outputTail,
+    status,
+    durationMs: artifact.durationMs ?? Math.max(0, Date.now() - started),
+    errors: [],
+    failedTests: artifact.failingTestIdentities ?? artifact.failingTests ?? [],
+    ...suiteFootprint && failedCount !== void 0 ? {
+      testsRun: suiteFootprint.executed + suiteFootprint.skipped,
+      testsPassed: Math.max(0, suiteFootprint.executed - failedCount),
+      testsFailed: failedCount,
+      testsSkipped: suiteFootprint.skipped
+    } : {},
+    captureError
+  };
+}
+async function captureVerificationBaseline(worktreePath, baselineRef, options = {}) {
+  const gateTimeoutMs = resolveVerifyCommandTimeoutMs(options.gateTimeoutMs);
+  const opts = { ...DEFAULT_OPTIONS, ...options, gateTimeoutMs };
+  const startTime = Date.now();
+  const captureErrors = [];
+  const sinceRef = opts.changedSinceRef && opts.changedSinceRef.trim().length > 0 ? opts.changedSinceRef.trim() : baselineRef;
+  const scope = resolveVerificationChannelScope(worktreePath, opts.changedFiles);
+  const buildCommands = channelCommands(scope.build);
+  const lintCommands = channelCommands(scope.lint);
+  const testCommands = selectScopedTestCommands(scope);
+  const buildRelevant = scope.build.relevant;
+  const lintRelevant = scope.lint.relevant;
+  const testRelevant = scope.test.relevant;
+  const buildUnavailable = scope.build.availability === "unavailable";
+  const lintUnavailable = scope.lint.availability === "unavailable";
+  const testUnavailable = scope.test.availability === "unavailable";
+  const skippedChannel = (result) => ({
+    result,
+    captureError: void 0,
+    language: "unknown",
+    parsed: false,
+    commands: [],
+    availability: "out_of_scope"
+  });
+  const [typecheck, lint, tests] = await withValidationSlot(
+    `baseline:${worktreePath}`,
+    () => Promise.all([
+      buildRelevant ? runCommandsSequentially(
+        buildCommands,
+        opts.gateTimeoutMs,
+        (command, timeoutMs) => captureTypecheckOnce(worktreePath, timeoutMs, opts.outputTailLines, command)
+      ).then(aggregateBuildCaptures) : Promise.resolve(
+        skippedChannel({
+          exitCode: 0,
+          count: 0,
+          errors: [],
+          outputTail: buildUnavailable ? "verification unavailable" : "not task-relevant"
+        })
+      ),
+      opts.skipLint || !lintRelevant ? Promise.resolve(
+        skippedChannel({
+          exitCode: 0,
+          count: 0,
+          errors: [],
+          outputTail: lintUnavailable ? "verification unavailable" : lintRelevant ? "skipped" : "not task-relevant"
+        })
+      ) : runCommandsSequentially(
+        lintCommands,
+        opts.gateTimeoutMs,
+        (command, timeoutMs) => captureLintOnce(worktreePath, sinceRef, timeoutMs, opts.outputTailLines, command)
+      ).then(aggregateLintCaptures),
+      opts.skipTests || !testRelevant ? Promise.resolve({
+        result: {
+          exitCode: 0,
+          passed: 0,
+          failed: 0,
+          failedTests: [],
+          outputTail: testUnavailable ? "verification unavailable" : testRelevant ? "skipped" : "not task-relevant"
+        },
+        captureError: void 0,
+        language: "unknown",
+        parsed: false,
+        commands: [],
+        availability: "out_of_scope"
+      }) : runCommandsSequentially(
+        testCommands,
+        opts.gateTimeoutMs,
+        (command, timeoutMs) => captureTestsOnce(worktreePath, sinceRef, timeoutMs, opts.outputTailLines, command)
+      ).then(aggregateTestCaptures)
+    ]),
+    // Same bound as runDeterministicGates: the slot wait must scale with the
+    // caller's own gate budget so pacing cannot breach an outer deadline.
+    { maxWaitMs: Math.min(5 * 60 * 1e3, Math.max(5e3, opts.gateTimeoutMs * 3)) }
+  );
+  if (typecheck.captureError) captureErrors.push(typecheck.captureError);
+  if (lint.captureError) captureErrors.push(lint.captureError);
+  if (tests.captureError) captureErrors.push(tests.captureError);
+  const durationMs = Date.now() - startTime;
+  const gateSummary = {
+    build: {
+      exitCode: typecheck.result.exitCode,
+      parsed: typecheck.parsed,
+      language: typecheck.language,
+      commands: typecheck.commands,
+      availability: buildUnavailable ? "unavailable" : buildRelevant ? typecheck.availability ?? "executed" : "out_of_scope"
+    },
+    lint: {
+      exitCode: lint.result.exitCode,
+      parsed: lint.parsed,
+      language: lint.language,
+      commands: lint.commands,
+      availability: opts.skipLint ? "out_of_scope" : lintUnavailable ? "unavailable" : lintRelevant && !opts.skipLint ? lint.availability ?? "executed" : "out_of_scope"
+    },
+    test: {
+      exitCode: tests.result.exitCode,
+      parsed: tests.parsed,
+      language: tests.language,
+      commands: tests.commands,
+      availability: opts.skipTests ? "out_of_scope" : testUnavailable ? "unavailable" : testRelevant && !opts.skipTests ? tests.availability ?? "executed" : "out_of_scope"
+    }
+  };
+  const regressionCount = Number(gateSummary.build.exitCode !== 0) + Number(gateSummary.lint.exitCode !== 0) + Number(gateSummary.test.exitCode !== 0);
+  const sentinelPresent = gateSummary.build.exitCode !== 0 && !gateSummary.build.parsed || gateSummary.lint.exitCode !== 0 && !gateSummary.lint.parsed || gateSummary.test.exitCode !== 0 && !gateSummary.test.parsed;
+  const perLanguage = Array.from(
+    new Set(
+      [
+        ...typecheck.commands.map((c) => c.language),
+        ...lint.commands.map((c) => c.language),
+        ...tests.commands.map((c) => c.language)
+      ].filter((language) => language && language !== "unknown")
+    )
+  );
+  return {
+    baselineRef,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    testResults: tests.result,
+    typeErrors: typecheck.result,
+    lintErrors: lint.result,
+    metadata: {
+      durationMs,
+      captureSucceeded: captureErrors.length === 0,
+      captureErrors
+    },
+    summary: {
+      schemaVersion: BASELINE_SCHEMA_VERSION,
+      regressionCount,
+      sentinelPresent,
+      perLanguage,
+      gates: gateSummary
+    }
+  };
+}
+function createEmptyBaseline(baselineRef, reason) {
+  return {
+    baselineRef,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    testResults: {
+      exitCode: 0,
+      passed: 0,
+      failed: 0,
+      failedTests: [],
+      outputTail: ""
+    },
+    typeErrors: {
+      exitCode: 0,
+      count: 0,
+      errors: [],
+      signaturesParseable: true,
+      outputTail: ""
+    },
+    lintErrors: {
+      exitCode: 0,
+      count: 0,
+      errors: [],
+      signaturesParseable: true,
+      outputTail: ""
+    },
+    metadata: {
+      durationMs: 0,
+      captureSucceeded: false,
+      captureErrors: [reason]
+    },
+    summary: {
+      schemaVersion: BASELINE_SCHEMA_VERSION,
+      regressionCount: 0,
+      sentinelPresent: false,
+      perLanguage: [],
+      gates: {
+        build: { exitCode: 0, parsed: true, language: "unknown", commands: [] },
+        lint: { exitCode: 0, parsed: true, language: "unknown", commands: [] },
+        test: { exitCode: 0, parsed: true, language: "unknown", commands: [] }
+      }
+    }
+  };
+}
+
+// src/core/verification/baseline-store.ts
+var BASELINE_LOCK_WAIT_MS = 5 * 6e4;
+var BASELINE_LOCK_STALE_MS = 6e4;
+var BASELINE_LOCK_OPTIONS = {
+  realpath: false,
+  stale: BASELINE_LOCK_STALE_MS,
+  update: 3e4,
+  // Coordination is observational: losing this lock must not throw from
+  // proper-lockfile's heartbeat callback and terminate the process.
+  onCompromised: () => void 0,
+  retries: {
+    retries: 180,
+    factor: 1.2,
+    minTimeout: 100,
+    maxTimeout: 2e3,
+    maxRetryTime: BASELINE_LOCK_WAIT_MS,
+    randomize: true
+  }
+};
+function scopeHash(changedFiles) {
+  if (!changedFiles || changedFiles.length === 0) return "";
+  const sorted = [...changedFiles].map((file) => file.trim()).filter(Boolean).sort();
+  if (sorted.length === 0) return "";
+  return createHash("sha256").update(sorted.join("\n")).digest("hex").slice(0, 12);
+}
+function cachePathForBaseline(cacheDir, baselineRef, changedSinceRef, changedFiles, skipTests) {
+  const scope = scopeHash(changedFiles);
+  const scopeSuffix = `${scope ? `--scope-${scope}` : ""}${skipTests ? "--no-tests" : ""}`;
+  if (changedSinceRef && changedSinceRef !== baselineRef) {
+    return join(cacheDir, `${baselineRef}--since-${changedSinceRef}${scopeSuffix}.json`);
+  }
+  return join(cacheDir, `${baselineRef}${scopeSuffix}.json`);
+}
+async function ensureNodeModulesForBaselineWorktree(repoRoot, worktreePath) {
+  await prepareWorktreeDependencies({ repoRoot, worktreePath, bestEffort: true });
+  await copyConfiguredEnvFilesToWorktree({ repoRoot, worktreePath });
+}
+function isFreshSchemaBaseline(cached) {
+  if (cached.metadata?.captureSucceeded !== true) return false;
+  if (!cached.summary) return false;
+  return cached.summary.schemaVersion === BASELINE_SCHEMA_VERSION;
+}
+async function readCachedBaseline(path3) {
+  try {
+    const raw = await readFile2(path3, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    if (typeof parsed.baselineRef !== "string") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeCachedBaseline(path3, baseline) {
+  await atomicWriteJson(path3, baseline);
+}
+async function tryAcquireBaselineLock(cacheFile) {
+  try {
+    return await lockfile.lock(cacheFile, BASELINE_LOCK_OPTIONS);
+  } catch {
+    return void 0;
+  }
+}
+async function addDetachedWorktree(repoRoot, ref) {
+  const base = await mkBuildTempDir("baseline-worktree");
+  const worktreePath = join(base, ref.slice(0, 12));
+  const added = await addScratchWorktree({ repoRoot, worktreePath, ref });
+  if (!added.ok) {
+    await rm(base, { recursive: true, force: true });
+    throw new Error(`Failed to create baseline worktree for ${ref}: ${added.detail}`);
+  }
+  try {
+    await ensureNodeModulesForBaselineWorktree(repoRoot, worktreePath);
+  } catch (error) {
+    await removeDetachedWorktree(repoRoot, worktreePath);
+    throw error;
+  }
+  return worktreePath;
+}
+async function removeDetachedWorktree(repoRoot, worktreePath) {
+  try {
+    await removeScratchWorktree({ repoRoot, worktreePath });
+  } finally {
+    const parent = dirname2(worktreePath);
+    await rm(parent, { recursive: true, force: true });
+  }
+}
+async function captureAndCacheVerificationBaseline(options, cacheFile) {
+  let worktreePath = null;
+  try {
+    worktreePath = await addDetachedWorktree(options.repoRoot, options.baselineRef);
+    const baseline = await captureVerificationBaseline(worktreePath, options.baselineRef, {
+      ...options.captureOptions,
+      // Default anchor matches baselineRef unless caller overrides.
+      changedSinceRef: options.captureOptions?.changedSinceRef ?? options.baselineRef
+    });
+    await writeCachedBaseline(cacheFile, baseline);
+    return baseline;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return createEmptyBaseline(options.baselineRef, message);
+  } finally {
+    if (worktreePath) {
+      await removeDetachedWorktree(options.repoRoot, worktreePath);
+    }
+  }
+}
+async function getOrCaptureVerificationBaseline(options) {
+  const cacheFile = cachePathForBaseline(
+    options.cacheDir,
+    options.baselineRef,
+    options.captureOptions?.changedSinceRef,
+    options.captureOptions?.changedFiles,
+    options.captureOptions?.skipTests
+  );
+  const cached = await readCachedBaseline(cacheFile);
+  if (cached && cached.baselineRef === options.baselineRef && isFreshSchemaBaseline(cached)) {
+    return cached;
+  }
+  await mkdir2(options.cacheDir, { recursive: true });
+  const releaseLock = await tryAcquireBaselineLock(cacheFile);
+  if (!releaseLock) {
+    const filledWhileWaiting = await readCachedBaseline(cacheFile);
+    if (filledWhileWaiting && filledWhileWaiting.baselineRef === options.baselineRef && isFreshSchemaBaseline(filledWhileWaiting)) {
+      return filledWhileWaiting;
+    }
+    return captureAndCacheVerificationBaseline(options, cacheFile);
+  }
+  try {
+    const filledByPeer = await readCachedBaseline(cacheFile);
+    if (filledByPeer && filledByPeer.baselineRef === options.baselineRef && isFreshSchemaBaseline(filledByPeer)) {
+      return filledByPeer;
+    }
+    return await captureAndCacheVerificationBaseline(options, cacheFile);
+  } finally {
+    await releaseLock().catch(() => void 0);
+  }
+}
+
+// src/orchestrator/worker-protocol.ts
+import { z } from "zod";
+var SETUP_COMPLETE_MARKER_PREFIX = "__BUILD_SETUP_COMPLETE_MS__:";
+var PROVIDER_START_MARKER_PREFIX = "__BUILD_PROVIDER_START_MS__:";
+var PROVIDER_COMPLETE_MARKER_PREFIX = "__BUILD_PROVIDER_COMPLETE_MS__:";
+var RESULT_WRITTEN_MARKER_PREFIX = "__BUILD_RESULT_WRITTEN_MS__:";
+var CLEANUP_START_MARKER_PREFIX = "__BUILD_CLEANUP_START_MS__:";
+var CLEANUP_COMPLETE_MARKER_PREFIX = "__BUILD_CLEANUP_COMPLETE_MS__:";
+var ACTIVE_HANDLES_MARKER_PREFIX = "__BUILD_ACTIVE_HANDLES__:";
+var POST_PROVIDER_PHASES_MARKER_PREFIX = "__BUILD_POST_PROVIDER_PHASES__:";
+var workerTerminationReasonSchema = z.enum([
+  "completed",
+  "timeout",
+  "canceled_early_exit",
+  "canceled_budget",
+  "canceled_user",
+  "failed_error",
+  "failed_crash"
+]);
+var workerErrorSchema = z.union([
+  z.string(),
+  z.object({
+    message: z.string().optional(),
+    name: z.string().optional(),
+    stack: z.string().optional()
+  }).passthrough()
+]);
+var providerResultSchema = z.object({
+  exitCode: z.number().int().nullable().optional(),
+  success: z.boolean().optional()
+}).passthrough();
+var workerResultPayloadSchema = z.object({
+  success: z.boolean(),
+  variant: z.string().min(1).optional(),
+  provider: z.string().min(1).optional(),
+  strategy: z.string().min(1).optional(),
+  duration: z.number().finite().nonnegative().optional(),
+  completeness: z.number().finite().min(0).max(100).optional(),
+  timedOut: z.boolean().optional(),
+  terminationReason: workerTerminationReasonSchema.optional(),
+  result: providerResultSchema.nullable().optional(),
+  error: workerErrorSchema.nullable().optional()
+}).passthrough().superRefine((value, context) => {
+  if (value.timedOut === true && value.terminationReason && value.terminationReason !== "timeout") {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["terminationReason"],
+      message: 'timedOut results must use terminationReason "timeout" when a reason is present'
+    });
+  }
+  if (value.timedOut === false && value.terminationReason === "timeout") {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["timedOut"],
+      message: 'terminationReason "timeout" cannot be paired with timedOut false'
+    });
+  }
+  if (value.success === true && value.terminationReason && value.terminationReason !== "completed") {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["terminationReason"],
+      message: "successful results cannot carry a failure or cancellation termination reason"
+    });
+  }
+});
+function validateWorkerResultPayload(parsed) {
+  const result = workerResultPayloadSchema.safeParse(parsed);
+  if (result.success) {
+    return { ok: true, value: result.data };
+  }
+  const detail = result.error.issues.map((issue) => {
+    const path3 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+    return `${path3}: ${issue.message}`;
+  }).join("; ");
+  return { ok: false, error: `invalid worker result payload (${detail})` };
+}
+
+export {
+  removeScratchWorktree,
+  addScratchWorktree,
+  withValidationSlot,
+  getOrCaptureVerificationBaseline,
+  SETUP_COMPLETE_MARKER_PREFIX,
+  PROVIDER_START_MARKER_PREFIX,
+  PROVIDER_COMPLETE_MARKER_PREFIX,
+  RESULT_WRITTEN_MARKER_PREFIX,
+  CLEANUP_START_MARKER_PREFIX,
+  CLEANUP_COMPLETE_MARKER_PREFIX,
+  ACTIVE_HANDLES_MARKER_PREFIX,
+  POST_PROVIDER_PHASES_MARKER_PREFIX,
+  validateWorkerResultPayload
+};
+//# sourceMappingURL=chunk-3C7WBIVK.js.map