@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-VBENAHDA.js

@@ -0,0 +1,1814 @@
+import {
+  acquireFencedFileLock
+} from "./chunk-QYQOVOLR.js";
+import {
+  abandonHostPublicationGenerationJournal,
+  attachOutstandingStatusPublicationMac,
+  beginHostPublicationGenerationJournal,
+  recoverHostPublicationGeneration,
+  syncHostPublicationGeneration
+} from "./chunk-4U6XK2DG.js";
+import {
+  parseProjectDependencySetupCommand,
+  parseTomlSections,
+  readComposerScripts,
+  tomlStrings
+} from "./chunk-AHU3FKPA.js";
+import {
+  repoRootStateKey
+} from "./chunk-BV3XQQLU.js";
+import {
+  processOwnershipState,
+  readProcessIdentity
+} from "./chunk-MT2WAIR3.js";
+
+// src/core/ci/local-ci-state.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+import { access, link, mkdir, readFile, rename, unlink, writeFile } from "fs/promises";
+import path4 from "path";
+import { z } from "zod";
+
+// src/core/ci/local-ci-entrypoint-fingerprint.ts
+import { createHash } from "crypto";
+import { lstatSync, readFileSync as readFileSync3, readlinkSync, realpathSync } from "fs";
+import * as path3 from "path";
+
+// src/core/ci/local-ci-composer-scripts.ts
+import { readFileSync } from "fs";
+import * as path from "path";
+var ALIAS_PREFIX = "\0scripts-aliases\0";
+var TARGET_SEPARATOR = "\n";
+function composerAliasKey(alias) {
+  return `${ALIAS_PREFIX}${alias}`;
+}
+function readComposerScriptTable(root) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path.join(root, "composer.json"), "utf8"));
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const table = { ...readComposerScripts(root) };
+  const aliases = parsed["scripts-aliases"];
+  if (aliases === void 0) return table;
+  if (!aliases || typeof aliases !== "object" || Array.isArray(aliases)) return null;
+  const targets = {};
+  for (const [target, names] of Object.entries(aliases)) {
+    if (!Array.isArray(names) || names.some((name) => typeof name !== "string")) return null;
+    for (const alias of names) targets[alias] = [...targets[alias] ?? [], target];
+  }
+  for (const [alias, aliasTargets] of Object.entries(targets)) {
+    table[composerAliasKey(alias)] = aliasTargets.sort().join(TARGET_SEPARATOR);
+  }
+  return table;
+}
+function composerRelatedScripts(name, scripts) {
+  const aliasKey = composerAliasKey(name);
+  const targets = scripts[aliasKey]?.split(TARGET_SEPARATOR) ?? [];
+  if (scripts[name] === void 0 && targets.length === 0) return null;
+  return [aliasKey, ...targets, "pre-command-run"];
+}
+
+// src/core/ci/local-ci-pyproject-scripts.ts
+import { readFileSync as readFileSync2 } from "fs";
+import * as path2 from "path";
+var OWNERS_BY_HEAD = {
+  uv: /* @__PURE__ */ new Set(["project"]),
+  poetry: /* @__PURE__ */ new Set(["project", "poetry"]),
+  pdm: /* @__PURE__ */ new Set(["project", "pdm"]),
+  hatch: /* @__PURE__ */ new Set(["project", "hatch"])
+};
+var SCRIPT_KEYS = /* @__PURE__ */ new Set(["scripts", "gui-scripts", "console_scripts"]);
+function classifyScriptsTable(keys) {
+  if (!keys.some((key) => SCRIPT_KEYS.has(key))) return void 0;
+  const [first, second, third, fourth] = keys;
+  if (first === "project" && keys.length === 2 && second && SCRIPT_KEYS.has(second)) {
+    return { owner: "project", subtable: false };
+  }
+  if (first === "tool" && second === "poetry" && third === "scripts" && keys.length === 3) {
+    return { owner: "poetry", subtable: false };
+  }
+  if (first === "tool" && second === "pdm" && third === "scripts") {
+    if (keys.length === 3) return { owner: "pdm", subtable: false };
+    if (keys.length === 4 && fourth) return { owner: "pdm", subtable: true };
+  }
+  if (first === "tool" && second === "hatch" && third === "envs" && keys[4] === "scripts") {
+    if (keys.length === 5) return { owner: "hatch", subtable: false };
+  }
+  return "unmodeled";
+}
+function readPyprojectScripts(root, head) {
+  const owners = OWNERS_BY_HEAD[head];
+  if (!owners) return null;
+  let text;
+  try {
+    text = readFileSync2(path2.join(root, "pyproject.toml"), "utf8");
+  } catch {
+    return null;
+  }
+  if (/"""|'''/.test(text)) return null;
+  let unread = false;
+  const sections = parseTomlSections(text, () => {
+    unread = true;
+  });
+  if (unread) return null;
+  const definitions = {};
+  const define = (name, definition) => {
+    definitions[name] = [...definitions[name] ?? [], definition];
+  };
+  for (const section of sections) {
+    const table = classifyScriptsTable(section.keys);
+    if (table === "unmodeled") return null;
+    if (table) {
+      if (!owners.has(table.owner)) continue;
+      const header = section.keys.join(".");
+      if (table.subtable) {
+        const entries = section.entries.map((entry) => `${entry.key}=${entry.value}`).join(";");
+        define(section.keys[3] ?? "", `[${header}] ${entries}`);
+      } else {
+        for (const entry of section.entries) {
+          if (entry.key.includes(".")) return null;
+          define(entry.key, `${header}.${entry.key}=${entry.value}`);
+        }
+      }
+      continue;
+    }
+    const mentionsScripts = section.entries.some(
+      (entry) => [...section.keys, ...entry.key.split(".")].some((key) => SCRIPT_KEYS.has(key))
+    );
+    if (mentionsScripts) return null;
+  }
+  return Object.fromEntries(
+    Object.entries(definitions).map(([name, lines]) => [name, lines.sort().join("\n")])
+  );
+}
+function pyprojectScriptReferences(body, scripts, head) {
+  const names = [];
+  for (const value of tomlStrings(body)) {
+    const words = value.trim().split(/\s+/);
+    if ((head === "hatch" || head === "pdm") && words[0] === head && words[1] === "run") {
+      const target = (words[2] ?? "").replace(/^['"]|['"]$/g, "");
+      if (!target || target.startsWith("-") || target.startsWith("+")) return null;
+      if (/[;&|\n`]|\$\(/.test(value)) return null;
+      names.push(head === "hatch" ? target.split(":").pop() ?? target : target);
+    } else {
+      names.push(words[0] ?? "");
+    }
+  }
+  return names.filter((name) => Object.hasOwn(scripts, name));
+}
+function pyprojectAutomaticScripts(head, name) {
+  return head === "pdm" ? [`pre_${name}`, `post_${name}`, "pre_script", "post_script", "pre_run", "post_run", "_"] : [];
+}
+
+// src/core/ci/local-ci-manifest-pins.ts
+var NODE_PACKAGE_MANAGER_MANIFESTS = ["package.json", ".npmrc"];
+var verbs = (...names) => new Set(names);
+var PYTHON_PYPROJECT = ["pyproject.toml"];
+var GRADLE_BUILD_FILES = [
+  "build.gradle",
+  "build.gradle.kts",
+  "settings.gradle",
+  "settings.gradle.kts"
+];
+var COMPOSER_PASSIVE_OPTIONS = /* @__PURE__ */ new Set([
+  "-q",
+  "--quiet",
+  "-n",
+  "--no-interaction",
+  "--ansi",
+  "--no-ansi",
+  "--dev",
+  "--no-dev"
+]);
+var COMPOSER_RUN_VERBS = /* @__PURE__ */ new Set(["run", "run-script"]);
+var COMPOSER_SETUP_VERBS = verbs("install");
+function launcherVerb(tokens) {
+  for (let index = 1; index < tokens.length; index += 1) {
+    const token = tokens[index] ?? "";
+    if (token.startsWith("+")) continue;
+    return token.startsWith("-") ? null : token.toLowerCase();
+  }
+  return null;
+}
+function composerReference(tokens) {
+  if (isSetupInvocation(COMPOSER_SETUP_VERBS, tokens)) return null;
+  let verbIndex = 1;
+  while (COMPOSER_PASSIVE_OPTIONS.has((tokens[verbIndex] ?? "").toLowerCase())) verbIndex += 1;
+  const verb = (tokens[verbIndex] ?? "").toLowerCase();
+  if (!verb || verb.startsWith("-")) return void 0;
+  let name = verb;
+  let nameIndex = verbIndex;
+  if (COMPOSER_RUN_VERBS.has(verb)) {
+    nameIndex = verbIndex + 1;
+    while (COMPOSER_PASSIVE_OPTIONS.has((tokens[nameIndex] ?? "").toLowerCase())) nameIndex += 1;
+    name = tokens[nameIndex] ?? "";
+    if (!name || name.startsWith("-")) return void 0;
+  }
+  for (const token of tokens.slice(nameIndex + 1)) {
+    if (token === "--") break;
+    if (/^-d/.test(token) || token.startsWith("--working-dir")) return void 0;
+  }
+  return name.replace(/^['"]|['"]$/g, "");
+}
+function composerReferences(body, scripts) {
+  return [...body.matchAll(/(?:^|\s)@([\w:.-]+)/g)].map((match) => match[1] ?? "").filter((name) => Object.hasOwn(scripts, name));
+}
+var COMPOSER_SCRIPTS = {
+  read: readComposerScriptTable,
+  references: composerReferences,
+  related: composerRelatedScripts,
+  referenced: composerReference
+};
+var PYTHON_WRAPPER_PASSIVE_OPTIONS = {
+  uv: verbs("--frozen", "--locked", "--no-sync", "--offline", "-q", "--quiet", "--no-dev"),
+  poetry: verbs("-q", "--quiet", "-v", "--verbose"),
+  pdm: verbs("-q", "--quiet", "-v", "--verbose"),
+  hatch: verbs()
+};
+function pythonWrapperReference(head, tokens) {
+  if ((tokens[1] ?? "").toLowerCase() !== "run") return void 0;
+  const passive = PYTHON_WRAPPER_PASSIVE_OPTIONS[head] ?? verbs();
+  let index = 2;
+  while (passive.has((tokens[index] ?? "").toLowerCase())) index += 1;
+  const target = (tokens[index] ?? "").replace(/^['"]|['"]$/g, "");
+  if (!target || target.startsWith("-") || target.startsWith("+")) return void 0;
+  return head === "hatch" ? target.split(":").pop() ?? target : target;
+}
+function pythonScripts(head) {
+  return {
+    read: (root) => readPyprojectScripts(root, head),
+    references: (body, scripts) => pyprojectScriptReferences(body, scripts, head),
+    related: (name) => pyprojectAutomaticScripts(head, name),
+    referenced: (tokens) => pythonWrapperReference(head, tokens)
+  };
+}
+var LAUNCHER_MANIFESTS = {
+  npm: { definitions: NODE_PACKAGE_MANAGER_MANIFESTS },
+  pnpm: { definitions: NODE_PACKAGE_MANAGER_MANIFESTS },
+  yarn: { definitions: NODE_PACKAGE_MANAGER_MANIFESTS },
+  bun: { definitions: NODE_PACKAGE_MANAGER_MANIFESTS },
+  npx: { definitions: NODE_PACKAGE_MANAGER_MANIFESTS },
+  pnpx: { definitions: NODE_PACKAGE_MANAGER_MANIFESTS },
+  bunx: { definitions: NODE_PACKAGE_MANAGER_MANIFESTS },
+  make: { definitions: ["Makefile", "GNUmakefile"] },
+  just: { definitions: ["justfile", ".justfile"] },
+  task: { definitions: ["Taskfile.yml", "Taskfile.yaml"] },
+  rake: { definitions: ["Rakefile"] },
+  tox: { definitions: ["tox.ini", "pyproject.toml", "setup.cfg"] },
+  nox: { definitions: ["noxfile.py"] },
+  // `run` names either a tool or a script the pyproject.toml defines; the script
+  // tables tell them apart. Every other verb stays pinned whole.
+  poetry: {
+    definitions: PYTHON_PYPROJECT,
+    setupVerbs: verbs("install"),
+    scriptTable: pythonScripts("poetry")
+  },
+  pdm: {
+    definitions: PYTHON_PYPROJECT,
+    setupVerbs: verbs("install", "sync"),
+    scriptTable: pythonScripts("pdm")
+  },
+  hatch: { definitions: PYTHON_PYPROJECT, scriptTable: pythonScripts("hatch") },
+  uv: {
+    definitions: PYTHON_PYPROJECT,
+    setupVerbs: verbs("sync"),
+    scriptTable: pythonScripts("uv")
+  },
+  pipenv: { definitions: ["Pipfile"], setupVerbs: verbs("install", "sync") },
+  composer: {
+    definitions: ["composer.json"],
+    setupVerbs: COMPOSER_SETUP_VERBS,
+    scriptTable: COMPOSER_SCRIPTS
+  },
+  cargo: {
+    definitions: [".cargo/config.toml"],
+    declarations: ["Cargo.toml"],
+    builtinVerbs: verbs("test", "build", "check", "clippy", "fmt", "fetch", "bench", "doc")
+  },
+  mvn: { definitions: ["pom.xml"] },
+  gradle: { definitions: GRADLE_BUILD_FILES },
+  gradlew: { definitions: GRADLE_BUILD_FILES },
+  swift: { definitions: ["Package.swift"] },
+  dart: {
+    definitions: [],
+    declarations: ["pubspec.yaml"],
+    builtinVerbs: verbs("test", "analyze", "format")
+  },
+  flutter: { definitions: ["pubspec.yaml"] },
+  deno: { definitions: ["deno.json", "deno.jsonc"] },
+  turbo: { definitions: ["turbo.json", "package.json"] },
+  nx: { definitions: ["nx.json", "package.json"] },
+  go: {
+    definitions: [],
+    declarations: ["go.mod"],
+    builtinVerbs: verbs("test", "build", "vet", "mod", "list")
+  }
+};
+function launcherManifests(head) {
+  return LAUNCHER_MANIFESTS[head];
+}
+function isSetupInvocation(setupVerbs, tokens) {
+  if (parseProjectDependencySetupCommand(tokens.join(" "))) return true;
+  const verb = launcherVerb(tokens);
+  return verb !== null && setupVerbs?.has(verb) === true;
+}
+function pinnedManifestFiles(manifests, tokens) {
+  if (isSetupInvocation(manifests.setupVerbs, tokens)) return [];
+  const verb = launcherVerb(tokens);
+  const builtin = verb !== null && manifests.builtinVerbs?.has(verb) === true;
+  return builtin ? manifests.definitions : [...manifests.definitions, ...manifests.declarations ?? []];
+}
+function referencedTableScript(head, tokens) {
+  const manifests = LAUNCHER_MANIFESTS[head];
+  const file = manifests?.definitions[0];
+  const reference = manifests?.scriptTable?.referenced(tokens);
+  if (!manifests?.scriptTable || !file || reference === null) return null;
+  return { file, name: reference };
+}
+var SCOPED_PIN_SEPARATOR = "\0";
+function scopedPinKey(file, head, name) {
+  return [file, head, name].join(SCOPED_PIN_SEPARATOR);
+}
+function parseScopedPin(key) {
+  const [file, head, name, ...rest] = key.split(SCOPED_PIN_SEPARATOR);
+  return file && head && name !== void 0 && rest.length === 0 ? { file, head, name } : null;
+}
+function scriptTableValues(head, names, trustedRoot, candidateRoot) {
+  const table = LAUNCHER_MANIFESTS[head]?.scriptTable;
+  if (!table) return null;
+  const base = table.read(trustedRoot);
+  const candidate = table.read(candidateRoot);
+  if (!base || !candidate) return null;
+  const pending = [...names].map((name) => ({ name, related: true }));
+  const seen = /* @__PURE__ */ new Set();
+  const expanded = /* @__PURE__ */ new Set();
+  const values = [];
+  const sides = [base, candidate];
+  while (pending.length > 0) {
+    const { name, related } = pending.pop() ?? { name: "", related: false };
+    const first = !seen.has(name);
+    if (!first && (!related || expanded.has(name))) continue;
+    if (first) {
+      seen.add(name);
+      values.push({ name, base: base[name], candidate: candidate[name] });
+      for (const side of sides) {
+        const body = side[name];
+        if (body !== void 0) {
+          const refs = table.references(body, side);
+          if (refs === null) return null;
+          pending.push(...refs.map((ref) => ({ name: ref, related: true })));
+        }
+      }
+    }
+    if (!related) continue;
+    expanded.add(name);
+    for (const side of sides) {
+      const extra = table.related?.(name, side);
+      if (extra === null) return null;
+      pending.push(...(extra ?? []).map((ref) => ({ name: ref, related: false })));
+    }
+  }
+  return values.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+}
+function scriptTableUnchanged(head, names, trustedRoot, candidateRoot) {
+  const values = scriptTableValues(head, names, trustedRoot, candidateRoot);
+  if (!values) return false;
+  return values.every((value) => value.base === value.candidate);
+}
+
+// src/core/ci/local-ci-entrypoint-fingerprint.ts
+var ENTRYPOINT_FINGERPRINT_VERSION = 1;
+var ENTRYPOINT_FINGERPRINT_PATTERN = /^v\d+:[a-f0-9]{64}$/;
+var Unbindable = class extends Error {
+};
+var sha256 = (value) => createHash("sha256").update(value).digest("hex");
+var isMissing = (error) => typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+function assertInsideRoot(root, absolute) {
+  const resolvedRoot = realpathSync(root);
+  const resolved = realpathSync(absolute);
+  if (resolved !== resolvedRoot && !resolved.startsWith(`${resolvedRoot}${path3.sep}`)) {
+    throw new Unbindable(`resolves outside the checkout: ${absolute}`);
+  }
+}
+function readSpelling(root, relativePath) {
+  const absolute = path3.join(root, relativePath);
+  let stat;
+  try {
+    stat = lstatSync(absolute);
+  } catch (error) {
+    if (isMissing(error)) return { type: "missing", executable: false, digest: "", lines: [] };
+    throw new Unbindable(`unreadable: ${absolute}`);
+  }
+  try {
+    assertInsideRoot(root, absolute);
+    const linkTarget = stat.isSymbolicLink() ? readlinkSync(absolute) : void 0;
+    const resolvedStat = linkTarget === void 0 ? stat : lstatSync(realpathSync(absolute));
+    const executable = (resolvedStat.mode & 73) !== 0;
+    if (!resolvedStat.isFile()) {
+      if (linkTarget !== void 0) throw new Unbindable(`link to a non-file: ${absolute}`);
+      return {
+        type: stat.isDirectory() ? "directory" : "other",
+        executable,
+        digest: "",
+        lines: []
+      };
+    }
+    const bytes = readFileSync3(absolute);
+    const lines = bytes.toString("utf8").split("\n");
+    if (linkTarget === void 0) return { type: "file", executable, digest: sha256(bytes), lines };
+    return {
+      type: "symlink",
+      executable,
+      digest: sha256(`link:${linkTarget}\0${sha256(bytes)}`),
+      lines: [linkTarget, ...lines],
+      linkTarget
+    };
+  } catch (error) {
+    if (error instanceof Unbindable) throw error;
+    throw new Unbindable(`cannot resolve: ${absolute}`);
+  }
+}
+function readSide(root, spellings) {
+  for (const spelling of spellings) {
+    const state = readSpelling(root, spelling);
+    if (state.type !== "missing") return state;
+  }
+  return { type: "missing", executable: false, digest: "", lines: [] };
+}
+function scriptSide(side, entries) {
+  const lines = entries.map(([name, value]) => JSON.stringify([name, value ?? null]));
+  return { ...side, digest: sha256(JSON.stringify([lines, side.linkTarget ?? null])), lines };
+}
+function lineDelta(base, candidate) {
+  const remaining = /* @__PURE__ */ new Map();
+  for (const line of base) remaining.set(line, (remaining.get(line) ?? 0) + 1);
+  let additions = 0;
+  for (const line of candidate) {
+    const count = remaining.get(line) ?? 0;
+    if (count > 0) remaining.set(line, count - 1);
+    else additions += 1;
+  }
+  let deletions = 0;
+  for (const count of remaining.values()) deletions += count;
+  return { additions, deletions };
+}
+function scriptEntries(input, file) {
+  if (file === "package.json" && input.packageScripts) {
+    const { names, base: base2, candidate: candidate2 } = input.packageScripts;
+    const sorted = [...names].sort();
+    return {
+      base: sorted.map((name) => [name, base2[name]]),
+      candidate: sorted.map((name) => [name, candidate2[name]])
+    };
+  }
+  const scoped = input.pins.scoped.get(file);
+  if (!scoped || input.pins.whole.has(file)) return void 0;
+  const base = [];
+  const candidate = [];
+  for (const head of [...new Set(scoped.map((script) => script.head))].sort()) {
+    const values = scriptTableValues(
+      head,
+      scoped.filter((script) => script.head === head).map((script) => script.name),
+      input.trustedRoot,
+      input.candidateRoot
+    );
+    if (!values) return void 0;
+    for (const value of values) {
+      base.push([`${head}:${value.name}`, value.base]);
+      candidate.push([`${head}:${value.name}`, value.candidate]);
+    }
+  }
+  return { base, candidate };
+}
+function computeEntrypointFingerprint(input) {
+  let paths;
+  try {
+    paths = [...input.redefined].sort().map((file) => {
+      const spellings = input.trackedPaths.get(file) ?? [];
+      if (spellings.length > 1) throw new Unbindable(`several spellings of ${file}`);
+      const baseFile = readSide(input.trustedRoot, spellings);
+      const candidateFile = readSide(input.candidateRoot, spellings);
+      if (baseFile.type === "missing" && candidateFile.type === "missing") {
+        throw new Unbindable(`neither side has ${file}`);
+      }
+      const entries = scriptEntries(input, file);
+      const base = entries ? scriptSide(baseFile, entries.base) : baseFile;
+      const candidate = entries ? scriptSide(candidateFile, entries.candidate) : candidateFile;
+      const side = (state) => ({
+        type: state.type,
+        executable: state.executable,
+        digest: state.digest
+      });
+      return {
+        path: file,
+        unit: entries ? "scripts" : "file",
+        base: side(base),
+        candidate: side(candidate),
+        ...lineDelta(base.lines, candidate.lines)
+      };
+    });
+  } catch (error) {
+    if (error instanceof Unbindable) return void 0;
+    throw error;
+  }
+  const scoped = [...input.pins.scoped.entries()].map(([file, scripts]) => ({ file, scripts: scripts.map((s) => `${s.head}:${s.name}`).sort() })).sort((a, b) => a.file < b.file ? -1 : a.file > b.file ? 1 : 0);
+  const document = {
+    version: ENTRYPOINT_FINGERPRINT_VERSION,
+    commands: input.commands,
+    pins: { whole: [...input.pins.whole].sort(), scoped },
+    paths
+  };
+  return `v${ENTRYPOINT_FINGERPRINT_VERSION}:${sha256(JSON.stringify(document))}`;
+}
+
+// src/core/ci/local-ci-state.ts
+function currentProcessIdentity() {
+  const identity = readProcessIdentity(process.pid);
+  if (!identity) throw new Error("Unable to establish local CI process identity.");
+  return identity;
+}
+var DEFAULT_LOCAL_CI_STATUS_CONTEXT = "Build Local CI";
+var DEFAULT_LOCAL_CI_MAX_CONCURRENT = 2;
+var LocalCiRunStatusSchema = z.enum([
+  "queued",
+  "running",
+  /**
+   * Validation passed; remote commit-status publication is not yet confirmed.
+   * Distinct from `succeeded_pending` (awaiting attestation preconditions).
+   */
+  "publication_pending",
+  "succeeded_pending",
+  "succeeded",
+  "skipped",
+  "failed",
+  "superseded"
+]);
+var LocalCiLegacyRunStatusSchema = z.enum(["succeeded_manual", "merged", "merge_blocked"]);
+var LocalCiPersistedRunStatusSchema = z.union([
+  LocalCiRunStatusSchema,
+  LocalCiLegacyRunStatusSchema
+]);
+function normalizeLocalCiRunStatus(status) {
+  switch (status) {
+    case "succeeded_manual":
+    case "merged":
+    case "merge_blocked":
+      return "succeeded";
+    default:
+      return status;
+  }
+}
+var LocalCiPublicationTargetStatusSchema = z.enum(["succeeded", "succeeded_pending"]);
+var LocalCiPersistedPublicationTargetStatusSchema = z.enum(["succeeded", "succeeded_pending", "succeeded_manual"]).transform(
+  (status) => status === "succeeded_manual" ? "succeeded" : status
+);
+var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["queued", "running"]);
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "publication_pending",
+  "succeeded_pending",
+  "succeeded",
+  "skipped",
+  "failed",
+  "superseded"
+]);
+function isLocalCiActiveStatus(status) {
+  return ACTIVE_STATUSES.has(status);
+}
+function isLocalCiTerminalStatus(status) {
+  return TERMINAL_STATUSES.has(status);
+}
+var MAX_LOCAL_CI_COMMAND_OUTPUT_BYTES = 16 * 1024;
+var MAX_LOCAL_CI_RETAINED_LOG_BYTES = 32 * 1024 * 1024;
+var LocalCiCommandResultSchema = z.object({
+  command: z.string().min(1),
+  exitCode: z.number().int(),
+  output: z.string(),
+  /** True when output is a bounded tail; the retained log may contain more under its budget. */
+  outputTruncated: z.boolean().optional(),
+  /** Complete UTF-8 byte length before inline output bounding. */
+  outputBytes: z.number().int().nonnegative().optional(),
+  id: z.string().min(1).optional(),
+  phase: z.string().min(1).optional(),
+  durationMs: z.number().int().nonnegative().optional()
+});
+var LocalCiFailingTestSchema = z.object({
+  /** Test file path when the identifier carried one (vitest/pytest/go path forms). */
+  file: z.string().min(1).optional(),
+  /** Failing test identifier (suite/test path, or raw name when no file parsed). */
+  test: z.string().min(1),
+  /** Verification phase of the failing step (e.g. 'verify'). */
+  phase: z.string().min(1)
+});
+var WorkerClaimPayloadSchema = z.object({
+  pid: z.number().int().positive(),
+  pidIdentity: z.string().min(1).optional(),
+  token: z.string().uuid(),
+  claimedAt: z.iso.datetime(),
+  /** Deterministic fingerprint of the authorized record generation; optional for legacy. */
+  generationKey: z.string().min(1).optional()
+});
+var CROSS_PROCESS_FS_LOCK_STALE_MS = 18e4;
+var CROSS_PROCESS_FS_LOCK_UPDATE_MS = 1e4;
+var PROPER_LOCKFILE_STALE_MIN_MS = 2e3;
+var PROPER_LOCKFILE_UPDATE_MIN_MS = 1e3;
+function resolveCrossProcessFsLockPolicy() {
+  const stale = Math.max(CROSS_PROCESS_FS_LOCK_STALE_MS, PROPER_LOCKFILE_STALE_MIN_MS);
+  const configuredUpdate = CROSS_PROCESS_FS_LOCK_UPDATE_MS;
+  const update = Math.max(Math.min(configuredUpdate, stale / 2), PROPER_LOCKFILE_UPDATE_MIN_MS);
+  return { stale, update };
+}
+var CROSS_PROCESS_FS_LOCK_OPTIONS = {
+  ...resolveCrossProcessFsLockPolicy(),
+  realpath: false,
+  retries: {
+    retries: 400,
+    minTimeout: 15,
+    maxTimeout: 100,
+    factor: 1.2
+  }
+};
+function boundLocalCiCommandOutput(result) {
+  const complete = Buffer.from(result.output, "utf8");
+  if (complete.byteLength <= MAX_LOCAL_CI_COMMAND_OUTPUT_BYTES) {
+    return result;
+  }
+  let start = complete.byteLength - MAX_LOCAL_CI_COMMAND_OUTPUT_BYTES;
+  while (start < complete.byteLength && (complete[start] & 192) === 128) {
+    start += 1;
+  }
+  return {
+    ...result,
+    output: complete.subarray(start).toString("utf8"),
+    outputTruncated: true,
+    outputBytes: complete.byteLength
+  };
+}
+function utf8Head(input, maxBytes) {
+  if (input.byteLength <= maxBytes) return input;
+  let end = Math.max(0, maxBytes);
+  while (end > 0 && end < input.byteLength && (input[end] & 192) === 128) {
+    end -= 1;
+  }
+  return input.subarray(0, end);
+}
+function utf8Tail(input, maxBytes) {
+  if (input.byteLength <= maxBytes) return input;
+  let start = input.byteLength - Math.max(0, maxBytes);
+  while (start < input.byteLength && (input[start] & 192) === 128) {
+    start += 1;
+  }
+  return input.subarray(start);
+}
+function renderBoundedLocalCiLogEntry(input) {
+  if (input.maxBytes <= 0) return "";
+  const completeOutput = Buffer.from(input.output, "utf8");
+  const complete = Buffer.from(
+    `${input.header}
+${input.output}${input.output.endsWith("\n") ? "" : "\n"}`,
+    "utf8"
+  );
+  if (complete.byteLength <= input.maxBytes) return complete.toString("utf8");
+  const marker = Buffer.from(
+    `
+[local-ci] transcript truncated: captured=${completeOutput.byteLength} bytes
+`,
+    "utf8"
+  );
+  const header = Buffer.from(`${input.header}
+`, "utf8");
+  const outputBudget = input.maxBytes - header.byteLength - marker.byteLength;
+  if (outputBudget <= 0) {
+    return utf8Head(Buffer.concat([header, marker]), input.maxBytes).toString("utf8");
+  }
+  const headBudget = Math.floor(outputBudget / 2);
+  const tailBudget = outputBudget - headBudget;
+  return Buffer.concat([
+    header,
+    utf8Head(completeOutput, headBudget),
+    marker,
+    utf8Tail(completeOutput, tailBudget)
+  ]).toString("utf8");
+}
+var LOCAL_CI_REPOSITORY_IDENTITY_MAX = 256;
+function parseLocalCiRepositoryIdentity(value) {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.length > LOCAL_CI_REPOSITORY_IDENTITY_MAX) return null;
+  if (/\s/.test(trimmed) || trimmed.includes("\\") || trimmed.includes("\0")) return null;
+  if (trimmed.startsWith("/") || trimmed.endsWith("/")) return null;
+  if (trimmed.includes("//")) return null;
+  const segments = trimmed.split("/");
+  if (segments.length < 2 || segments.length > 24) return null;
+  for (const segment of segments) {
+    if (!segment || segment === "." || segment === "..") return null;
+    if (!/^[A-Za-z0-9._~+-]+$/.test(segment)) return null;
+  }
+  return trimmed;
+}
+var LocalCiRepositoryIdentitySchema = z.string().refine((value) => parseLocalCiRepositoryIdentity(value) !== null, {
+  message: "Invalid local CI repository identity"
+});
+var OutstandingRemoteStatusPublicationSchema = z.object({
+  repository: LocalCiRepositoryIdentitySchema,
+  sha: z.string().regex(/^[a-f0-9]{40}$/i),
+  context: z.string().min(1).max(100),
+  state: z.enum(["failure", "success", "pending"]),
+  description: z.string().min(1).max(140),
+  /**
+   * Local status to apply once remote publication is confirmed. Required for
+   * success/pending remote states; omitted for failure (record is already failed).
+   * Legacy `succeeded_manual` normalizes to `succeeded` at read time.
+   */
+  targetStatus: LocalCiPersistedPublicationTargetStatusSchema.optional(),
+  /**
+   * Host-issued generation bound outside candidate-writable state.
+   * Optional on disk so legacy records still parse; the publisher fails closed
+   * when this is missing or does not match the host generation file.
+   */
+  generation: z.string().uuid().optional(),
+  /**
+   * Host-keyed HMAC over repository/sha/context/state/description/targetStatus
+   * and generation. Optional on disk so legacy records still parse; the
+   * publisher fails closed when this is missing or invalid and never publishes
+   * success.
+   */
+  mac: z.string().regex(/^[a-f0-9]{64}$/i).optional()
+}).superRefine((value, ctx) => {
+  if (value.state === "failure" && value.targetStatus !== void 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Failure status publications must not carry a success targetStatus.",
+      path: ["targetStatus"]
+    });
+  }
+  if (value.state !== "failure" && value.targetStatus === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Success-path status publications require targetStatus.",
+      path: ["targetStatus"]
+    });
+  }
+});
+var FailurePublicationLeaseSchema = z.object({
+  /** Unique lease token; required for post-publish clear/readback authorization. */
+  token: z.string().uuid(),
+  /** Process that holds the in-flight remote publication. */
+  ownerPid: z.number().int().positive(),
+  ownerPidIdentity: z.string().min(1).optional(),
+  /**
+   * Fingerprint of the record generation authorized for this remote write
+   * (same identity fields as record CAS, frozen at lease acquire).
+   */
+  generationKey: z.string().min(1),
+  claimedAt: z.iso.datetime()
+});
+var LocalCiRunRecordSchema = z.object({
+  schemaVersion: z.literal(1),
+  repoRoot: z.string().min(1),
+  repository: LocalCiRepositoryIdentitySchema,
+  sha: z.string().regex(/^[a-f0-9]{40}$/i),
+  branch: z.string().min(1),
+  remote: z.string().min(1),
+  statusContext: z.string().min(1).max(100),
+  maxConcurrent: z.number().int().min(1).max(8),
+  status: LocalCiPersistedRunStatusSchema,
+  commands: z.array(LocalCiCommandResultSchema),
+  /** Immutable branch-submission order; legacy records fall back to createdAt. */
+  submittedAt: z.iso.datetime().optional(),
+  createdAt: z.iso.datetime(),
+  updatedAt: z.iso.datetime(),
+  startedAt: z.iso.datetime().optional(),
+  queueWaitMs: z.number().int().nonnegative().optional(),
+  pid: z.number().int().positive().optional(),
+  /** OS start identity paired with pid so PID reuse is not mistaken for the worker. */
+  pidIdentity: z.string().min(1).optional(),
+  worktreePath: z.string().min(1).optional(),
+  /** Count of automatic unresolved-trusted-base recovery requeues. */
+  recoveryAttempts: z.number().int().nonnegative().optional(),
+  error: z.string().min(1).optional(),
+  trustedBaseRef: z.string().min(1).optional(),
+  trustedBaseSha: z.string().regex(/^[a-f0-9]{40}$/i).optional(),
+  /** Open PR identity observed when the exact head/base pair was admitted. */
+  pullRequestNumber: z.number().int().positive().optional(),
+  /** Pre-validation hold: an intentional entrypoint change still needs exact-SHA approval. */
+  entrypointApprovalPending: z.boolean().optional(),
+  /** Fingerprint of the redefined entrypoint definitions (local-ci-entrypoint-fingerprint.ts), for status and holds. */
+  entrypointFingerprint: z.string().regex(ENTRYPOINT_FINGERPRINT_PATTERN).optional(),
+  /**
+   * Authority-selected validation profile id (`full` or trusted-base profile).
+   * Optional for legacy records; missing means pre-profile runs (treat as full).
+   * Telemetry / runtime propagation only — never changes pass/fail by itself.
+   */
+  validationProfile: z.string().min(1).max(64).optional(),
+  /**
+   * Human-readable reason for {@link validationProfile}. Optional for legacy.
+   */
+  validationProfileReason: z.string().min(1).max(500).optional(),
+  /**
+   * Immediate failed predecessor whose successful release-gate slices may be
+   * reused once. Submission assigns this only on the first same-branch
+   * successor; the worker revalidates every retry invariant before use.
+   */
+  retryOfSha: z.string().regex(/^[a-f0-9]{40}$/i).optional(),
+  /** Successor SHA that atomically claimed this failed run's one retry slot. */
+  retryClaimedBySha: z.string().regex(/^[a-f0-9]{40}$/i).optional(),
+  /** Durable provenance for an accepted or attempted release-gate slice retry. */
+  gateRetry: z.object({
+    sourceSha: z.string().regex(/^[a-f0-9]{40}$/i),
+    manifestDigest: z.string().regex(/^[a-f0-9]{64}$/),
+    rerunLabels: z.array(z.string().min(1).max(120)).min(1).max(200),
+    reusedLabels: z.array(z.string().min(1).max(120)).min(1).max(200),
+    applied: z.boolean().optional()
+  }).optional(),
+  /**
+   * Structured failing tests parsed from a failed test-phase command's captured
+   * output. Telemetry only — never consulted by pass/fail decisions.
+   */
+  failingTests: z.array(LocalCiFailingTestSchema).optional(),
+  /** True when failingTests hit the retention cap and dropped further entries. */
+  failingTestsTruncated: z.boolean().optional(),
+  /**
+   * Set when the run failed while materializing (slot, worktree, executed tree)
+   * before any candidate command ran. Excluded from the consecutive-failure halt.
+   */
+  failureClass: z.literal("infrastructure").optional(),
+  /**
+   * Historical cross-machine verdict reuse provenance. The verdict cache was
+   * removed and nothing writes this field; it stays accepted so retained run
+   * records that carry it still parse.
+   */
+  verdictReuse: z.object({
+    /** Verdict ref that authorized the skip. */
+    ref: z.string().min(1).max(300),
+    /** Executed tree the verdict attests to (field name retained). */
+    mergeTree: z.string().min(1).max(64),
+    /** Machine that originally produced the verdict (provenance only). */
+    producer: z.string().min(1).max(32),
+    /** Completion time of the ORIGINAL validating run. */
+    originallyCompletedAt: z.string().min(1).max(64)
+  }).optional(),
+  /**
+   * Outstanding remote status publication (failure or success-path). Present
+   * until exact-context readback confirms the remote state; blocks terminal
+   * retention deletion. Success-path records use status `publication_pending`
+   * until publication is confirmed.
+   */
+  outstandingRemoteStatusPublication: OutstandingRemoteStatusPublicationSchema.optional(),
+  /**
+   * In-flight remote status publication lease (historical field name). Blocks
+   * fresh-generation establishment while the exact owner process is alive;
+   * recoverable when the owner is dead or the PID has been reused.
+   */
+  failurePublicationLease: FailurePublicationLeaseSchema.optional()
+}).transform((record) => ({
+  ...record,
+  status: normalizeLocalCiRunStatus(record.status)
+}));
+function hasOutstandingRemoteStatusPublication(record) {
+  return record.outstandingRemoteStatusPublication !== void 0;
+}
+function isPublicationPending(record) {
+  return record.status === "publication_pending";
+}
+function outstandingStatusPublicationMatchesRecord(record, obligation) {
+  return obligation.repository === record.repository && obligation.sha.toLowerCase() === record.sha.toLowerCase();
+}
+function hasLiveFailurePublicationLease(record) {
+  const lease = record.failurePublicationLease;
+  if (!lease) return false;
+  return processOwnershipState(lease.ownerPid, lease.ownerPidIdentity, lease.claimedAt) !== "reclaimable";
+}
+function resolveFailurePublicationClaimedAt(currentUpdatedAt, candidateClaimedAt) {
+  const currentMs = Date.parse(currentUpdatedAt);
+  const candidateMs = Date.parse(candidateClaimedAt);
+  if (!Number.isFinite(currentMs)) {
+    return Number.isFinite(candidateMs) ? new Date(candidateMs).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+  }
+  const floorMs = currentMs + 1;
+  if (!Number.isFinite(candidateMs)) {
+    return new Date(floorMs).toISOString();
+  }
+  return new Date(Math.max(candidateMs, floorMs)).toISOString();
+}
+function createFailurePublicationLease(current, claimedAt) {
+  const resolvedClaimedAt = resolveFailurePublicationClaimedAt(
+    current.updatedAt,
+    claimedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  );
+  const postAcquisitionGeneration = {
+    ...current,
+    updatedAt: resolvedClaimedAt,
+    // Lease attached below; field is not part of the generation fingerprint.
+    failurePublicationLease: void 0
+  };
+  const lease = FailurePublicationLeaseSchema.parse({
+    token: randomUUID(),
+    ownerPid: process.pid,
+    ownerPidIdentity: currentProcessIdentity(),
+    generationKey: localCiRecordGenerationKey(postAcquisitionGeneration),
+    claimedAt: resolvedClaimedAt
+  });
+  const leased = {
+    ...postAcquisitionGeneration,
+    failurePublicationLease: lease
+  };
+  return { lease, leased };
+}
+function matchesFailurePublicationLease(record, lease) {
+  const current = record.failurePublicationLease;
+  if (!current) return false;
+  if (current.token !== lease.token || current.generationKey !== lease.generationKey || current.ownerPid !== lease.ownerPid || current.ownerPidIdentity !== lease.ownerPidIdentity || current.claimedAt !== lease.claimedAt) {
+    return false;
+  }
+  return localCiRecordGenerationKey(record) === lease.generationKey;
+}
+function isSameLocalCiRecordGeneration(current, expected) {
+  return localCiRecordGenerationKey(current) === localCiRecordGenerationKey(expected);
+}
+function localCiRecordGenerationKey(record) {
+  const obligation = record.outstandingRemoteStatusPublication;
+  const material = [
+    record.repository,
+    record.sha.toLowerCase(),
+    record.status,
+    record.submittedAt ?? record.createdAt,
+    record.createdAt,
+    record.updatedAt,
+    obligation ? [
+      obligation.repository,
+      obligation.sha.toLowerCase(),
+      obligation.context,
+      obligation.state,
+      obligation.description,
+      obligation.targetStatus ?? "",
+      obligation.mac ?? ""
+    ].join("\0") : ""
+  ].join("\0");
+  return createHash2("sha256").update(material).digest("hex");
+}
+function createOutstandingStatusPublication(record, input) {
+  if (input.state === "failure" && input.targetStatus !== void 0) {
+    throw new Error("Failure status publications must not carry a success targetStatus.");
+  }
+  if (input.state !== "failure" && input.targetStatus === void 0) {
+    throw new Error("Success-path status publications require targetStatus.");
+  }
+  const parsed = OutstandingRemoteStatusPublicationSchema.parse({
+    repository: record.repository,
+    sha: record.sha.toLowerCase(),
+    context: record.statusContext,
+    state: input.state,
+    description: input.description.slice(0, 140),
+    ...input.targetStatus !== void 0 ? { targetStatus: input.targetStatus } : {}
+  });
+  return OutstandingRemoteStatusPublicationSchema.parse(
+    attachOutstandingStatusPublicationMac(parsed)
+  );
+}
+function createOutstandingFailureStatusPublication(record, description) {
+  return createOutstandingStatusPublication(record, {
+    state: "failure",
+    description
+  });
+}
+var DEFAULT_LOCAL_CI_MAX_TERMINAL_RECORDS = 50;
+function resolveMaxTerminalRecords(value) {
+  if (value !== void 0 && Number.isInteger(value) && value >= 0) {
+    return value;
+  }
+  return DEFAULT_LOCAL_CI_MAX_TERMINAL_RECORDS;
+}
+function compareRecordsNewestFirst(a, b) {
+  const byCreated = b.createdAt.localeCompare(a.createdAt);
+  if (byCreated !== 0) return byCreated;
+  return b.sha.localeCompare(a.sha);
+}
+function submissionTime(record) {
+  return record.submittedAt ?? record.createdAt;
+}
+function compareSubmissionsNewestFirst(a, b) {
+  const bySubmitted = submissionTime(b).localeCompare(submissionTime(a));
+  if (bySubmitted !== 0) return bySubmitted;
+  return b.sha.localeCompare(a.sha);
+}
+function createQueuedRun(input) {
+  const timestamp = (input.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const repository = parseLocalCiRepositoryIdentity(input.repository);
+  if (!repository) {
+    throw new Error(`Invalid local CI repository identity: ${input.repository}`);
+  }
+  return LocalCiRunRecordSchema.parse({
+    schemaVersion: 1,
+    repoRoot: path4.resolve(input.repoRoot),
+    repository,
+    sha: input.sha.toLowerCase(),
+    branch: input.branch,
+    remote: input.remote,
+    statusContext: input.statusContext ?? DEFAULT_LOCAL_CI_STATUS_CONTEXT,
+    maxConcurrent: input.maxConcurrent ?? DEFAULT_LOCAL_CI_MAX_CONCURRENT,
+    retryOfSha: input.retryOfSha?.toLowerCase(),
+    status: "queued",
+    commands: [],
+    submittedAt: timestamp,
+    createdAt: timestamp,
+    updatedAt: timestamp
+  });
+}
+function repoStateKey(repository) {
+  const identity = parseLocalCiRepositoryIdentity(repository) ?? repository.trim();
+  const readable = identity.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+  const digest = createHash2("sha256").update(identity).digest("hex").slice(0, 12);
+  return `${readable || "repository"}-${digest}`;
+}
+function stateReadError(filePath, cause) {
+  const detail = cause instanceof Error ? cause.message : String(cause);
+  return new Error(`Invalid local CI state at ${filePath}: ${detail}`, { cause });
+}
+function isNodeErrorCode(error, code) {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === code);
+}
+function isPathUnderRoot(root, candidatePath) {
+  const resolvedRoot = path4.resolve(root);
+  const resolvedCandidate = path4.resolve(candidatePath);
+  const relative = path4.relative(resolvedRoot, resolvedCandidate);
+  return relative !== "" && !relative.startsWith("..") && !path4.isAbsolute(relative);
+}
+var LocalCiStateStore = class {
+  constructor(root, hooks = {}) {
+    this.root = root;
+    this.hooks = hooks;
+  }
+  root;
+  hooks;
+  repositoryDirectory(repository) {
+    return path4.join(this.root, repoStateKey(repository));
+  }
+  filePath(repository, sha) {
+    return path4.join(this.repositoryDirectory(repository), `${sha.toLowerCase()}.json`);
+  }
+  logPath(repository, sha) {
+    return path4.join(this.repositoryDirectory(repository), `${sha.toLowerCase()}.log`);
+  }
+  workerClaimPath(repository, sha) {
+    return path4.join(this.repositoryDirectory(repository), `${sha.toLowerCase()}.worker.lock`);
+  }
+  /**
+   * Synthetic proper-lockfile target for worker-claim mutations (never created).
+   * Distinct from the claim payload path and from the record JSON path.
+   */
+  workerClaimMutexTarget(repository, sha) {
+    return path4.join(
+      this.repositoryDirectory(repository),
+      `${sha.toLowerCase()}.worker.claim.mutex`
+    );
+  }
+  /**
+   * Serialize claim create/stale-reclaim, transfer, and release for one SHA.
+   *
+   * Lock order (mandatory, never reverse):
+   * 1. record mutation lock (when proving authorized generation)
+   * 2. claim mutation lock
+   *
+   * claimWorker nests claim under record. transfer/release take claim only and
+   * must never acquire the record lock while holding claim.
+   *
+   * Uses fenced proper-lockfile ownership (owner token) so a resumed predecessor
+   * after stale reclaim cannot unlock/remove a successor's lock path.
+   */
+  async withWorkerClaimMutationLock(repository, sha, fn) {
+    const lockTarget = this.workerClaimMutexTarget(repository, sha);
+    await mkdir(path4.dirname(lockTarget), { recursive: true, mode: 448 });
+    const held = await acquireFencedFileLock(lockTarget, {
+      ...this.resolveFsLockOptions(),
+      description: "Local CI worker claim lock"
+    });
+    try {
+      if (this.hooks.afterClaimLockAcquired) {
+        await this.hooks.afterClaimLockAcquired();
+      }
+      await held.assertOwned();
+      return await fn(held);
+    } finally {
+      await held();
+    }
+  }
+  /**
+   * Run `fn` while holding the exclusive per-record mutation lock.
+   * Non-reentrant for the same lock class.
+   *
+   * Locks the stable record JSON path without creating it (`realpath: false`).
+   * May nest the claim mutation lock inside (record → claim only).
+   *
+   * Fenced with an owner token: assert ownership before state-changing writes and
+   * across await boundaries; release is a no-op if superseded.
+   */
+  async withRecordMutationLock(repository, sha, fn) {
+    const lockTarget = this.filePath(repository, sha);
+    await mkdir(path4.dirname(lockTarget), { recursive: true, mode: 448 });
+    const held = await acquireFencedFileLock(lockTarget, {
+      ...this.resolveFsLockOptions(),
+      description: "Local CI record lock"
+    });
+    try {
+      if (this.hooks.afterRecordLockAcquired) {
+        await this.hooks.afterRecordLockAcquired();
+      }
+      await held.assertOwned();
+      return await fn(held);
+    } finally {
+      await held();
+    }
+  }
+  /** Shared lock options; test hooks may override floors-respecting timings. */
+  resolveFsLockOptions() {
+    const overrides = this.hooks.lockOptions;
+    if (!overrides) return CROSS_PROCESS_FS_LOCK_OPTIONS;
+    const base = resolveCrossProcessFsLockPolicy();
+    const stale = Math.max(overrides.stale ?? base.stale, PROPER_LOCKFILE_STALE_MIN_MS);
+    const configuredUpdate = overrides.update ?? base.update;
+    const update = Math.max(Math.min(configuredUpdate, stale / 2), PROPER_LOCKFILE_UPDATE_MIN_MS);
+    return {
+      ...CROSS_PROCESS_FS_LOCK_OPTIONS,
+      stale,
+      update
+    };
+  }
+  async readUnlocked(repository, sha) {
+    const filePath = this.filePath(repository, sha);
+    try {
+      const raw = await readFile(filePath, "utf8");
+      return LocalCiRunRecordSchema.parse(JSON.parse(raw));
+    } catch (error) {
+      throw stateReadError(filePath, error);
+    }
+  }
+  /**
+   * Write a run record under an already-held record mutation fence.
+   *
+   * Awaits (mkdir, temp write) may outlive a predecessor's stale window; re-assert
+   * the fence immediately before the final rename that publishes the record so a
+   * superseded holder cannot overwrite successor state.
+   */
+  async writeRecordUnlocked(record, fence) {
+    const parsed = LocalCiRunRecordSchema.parse(record);
+    const filePath = this.filePath(parsed.repository, parsed.sha);
+    await mkdir(path4.dirname(filePath), { recursive: true, mode: 448 });
+    const temporary = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(parsed, null, 2)}
+`, {
+      encoding: "utf8",
+      mode: 384
+    });
+    const attemptId = beginHostPublicationGenerationJournal(parsed);
+    try {
+      await fence.assertOwned();
+      await rename(temporary, filePath);
+    } catch (error) {
+      abandonHostPublicationGenerationJournal(parsed, attemptId);
+      await unlink(temporary).catch(() => void 0);
+      throw error;
+    }
+    syncHostPublicationGeneration(parsed, attemptId);
+    return parsed;
+  }
+  /**
+   * Acquire exclusive worker ownership for the authorized record generation.
+   *
+   * Lock order: record mutation lock, then claim mutation lock (never reverse).
+   * Under the record lock, re-read the on-disk record and require
+   * {@link isSameLocalCiRecordGeneration} with `authorized`. If the disk
+   * generation differs, return null without touching the claim (prevents a
+   * stale launcher from superseding a fresher claim after the fact).
+   *
+   * Same-generation and legacy claims coalesce unless their owner is reclaimable.
+   * A different authorized generation may supersede an old claim even if its owner lives.
+   */
+  async claimWorker(authorized) {
+    const repository = authorized.repository;
+    const normalizedSha = authorized.sha.toLowerCase();
+    const generationKey = localCiRecordGenerationKey(authorized);
+    return this.withRecordMutationLock(repository, normalizedSha, async (recordFence) => {
+      await recordFence.assertOwned();
+      let onDisk;
+      try {
+        onDisk = await this.readUnlocked(repository, normalizedSha);
+      } catch {
+        return null;
+      }
+      await recordFence.assertOwned();
+      if (!isSameLocalCiRecordGeneration(onDisk, authorized)) {
+        return null;
+      }
+      return this.withWorkerClaimMutationLock(repository, normalizedSha, async (claimFence) => {
+        await claimFence.assertOwned();
+        const filePath = this.workerClaimPath(repository, normalizedSha);
+        await mkdir(path4.dirname(filePath), { recursive: true, mode: 448 });
+        await claimFence.assertOwned();
+        try {
+          const current = WorkerClaimPayloadSchema.parse(
+            JSON.parse(await readFile(filePath, "utf8"))
+          );
+          await claimFence.assertOwned();
+          const currentGeneration = current.generationKey;
+          if (currentGeneration === generationKey) {
+            if (processOwnershipState(current.pid, current.pidIdentity, current.claimedAt) !== "reclaimable") {
+              return null;
+            }
+            await claimFence.assertOwned();
+            await unlink(filePath).catch((unlinkError) => {
+              if (!isNodeErrorCode(unlinkError, "ENOENT")) throw unlinkError;
+            });
+          } else if (currentGeneration === void 0) {
+            if (processOwnershipState(current.pid, current.pidIdentity, current.claimedAt) !== "reclaimable") {
+              return null;
+            }
+            await claimFence.assertOwned();
+            await unlink(filePath).catch((unlinkError) => {
+              if (!isNodeErrorCode(unlinkError, "ENOENT")) throw unlinkError;
+            });
+          } else {
+            await claimFence.assertOwned();
+            await unlink(filePath).catch((unlinkError) => {
+              if (!isNodeErrorCode(unlinkError, "ENOENT")) throw unlinkError;
+            });
+          }
+        } catch (readError) {
+          if (isNodeErrorCode(readError, "ENOENT")) {
+          } else {
+            await claimFence.assertOwned();
+            await unlink(filePath).catch((unlinkError) => {
+              if (!isNodeErrorCode(unlinkError, "ENOENT")) throw unlinkError;
+            });
+          }
+        }
+        const claim = WorkerClaimPayloadSchema.parse({
+          pid: process.pid,
+          pidIdentity: currentProcessIdentity(),
+          token: randomUUID(),
+          claimedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          generationKey
+        });
+        const temporary = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+        await writeFile(temporary, `${JSON.stringify(claim)}
+`, {
+          encoding: "utf8",
+          mode: 384
+        });
+        try {
+          await claimFence.assertOwned();
+          await link(temporary, filePath);
+          await unlink(temporary).catch(() => void 0);
+          return {
+            ...claim,
+            generationKey,
+            filePath,
+            repository,
+            sha: normalizedSha
+          };
+        } catch (error) {
+          await unlink(temporary).catch(() => void 0);
+          if (isNodeErrorCode(error, "EEXIST")) return null;
+          throw error;
+        }
+      });
+    });
+  }
+  /**
+   * Transfer claim ownership to a spawned worker PID. Token + generation must
+   * still match under the claim mutex; a superseded claim cannot transfer.
+   */
+  async transferWorkerClaim(claim, pid, pidIdentity) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+      throw new Error("transferWorkerClaim requires a positive integer pid.");
+    }
+    if (pidIdentity !== void 0 && pidIdentity.trim().length === 0) {
+      throw new Error("transferWorkerClaim requires a process identity.");
+    }
+    return this.withWorkerClaimMutationLock(claim.repository, claim.sha, async (fence) => {
+      await fence.assertOwned();
+      let current;
+      try {
+        current = WorkerClaimPayloadSchema.parse(
+          JSON.parse(await readFile(claim.filePath, "utf8"))
+        );
+      } catch (error) {
+        throw new Error(
+          `Local CI worker claim missing during transfer at ${claim.filePath}: ${error instanceof Error ? error.message : String(error)}`,
+          { cause: error }
+        );
+      }
+      await fence.assertOwned();
+      if (current.token !== claim.token) {
+        throw new Error("Local CI worker claim ownership changed.");
+      }
+      if (current.generationKey !== claim.generationKey) {
+        throw new Error("Local CI worker claim generation changed.");
+      }
+      const transferred = WorkerClaimPayloadSchema.parse({
+        ...current,
+        pid,
+        pidIdentity: pidIdentity ?? readProcessIdentity(pid),
+        generationKey: claim.generationKey
+      });
+      const temporary = `${claim.filePath}.${process.pid}.${randomUUID()}.tmp`;
+      await writeFile(temporary, `${JSON.stringify(transferred)}
+`, {
+        encoding: "utf8",
+        mode: 384
+      });
+      await fence.assertOwned();
+      try {
+        await rename(temporary, claim.filePath);
+      } catch (error) {
+        await unlink(temporary).catch(() => void 0);
+        throw error;
+      }
+      return {
+        ...transferred,
+        generationKey: claim.generationKey,
+        filePath: claim.filePath,
+        repository: claim.repository,
+        sha: claim.sha
+      };
+    });
+  }
+  /**
+   * Release a claim only when on-disk owner pid (and optional generation) still
+   * match. Serialized under the claim mutex so release cannot unlink a
+   * generation-superseded successor.
+   *
+   * When `generationKey` is supplied, require exact equality with the on-disk
+   * claim's generationKey (including refusing when the on-disk key is undefined
+   * legacy) so new cleanup cannot delete a legacy claim on PID reuse.
+   */
+  async releaseWorkerClaim(repository, sha, pid, generationKey) {
+    const normalizedSha = sha.toLowerCase();
+    await this.withWorkerClaimMutationLock(repository, normalizedSha, async (fence) => {
+      await fence.assertOwned();
+      const filePath = this.workerClaimPath(repository, normalizedSha);
+      try {
+        const current = WorkerClaimPayloadSchema.parse(
+          JSON.parse(await readFile(filePath, "utf8"))
+        );
+        await fence.assertOwned();
+        if (current.pid !== pid) return;
+        if (generationKey !== void 0 && current.generationKey !== generationKey) {
+          return;
+        }
+        await fence.assertOwned();
+        await unlink(filePath);
+      } catch (error) {
+        if (!isNodeErrorCode(error, "ENOENT")) throw error;
+      }
+    });
+  }
+  rootMappingPath(repoRoot) {
+    return path4.join(this.root, "roots", `${repoRootStateKey(repoRoot)}.json`);
+  }
+  async registerRepositoryRoot(repository, repoRoot) {
+    const filePath = this.rootMappingPath(repoRoot);
+    await mkdir(path4.dirname(filePath), { recursive: true, mode: 448 });
+    await writeFile(
+      filePath,
+      `${JSON.stringify({ repository, repoRoot: path4.resolve(repoRoot) }, null, 2)}
+`,
+      { encoding: "utf8", mode: 384 }
+    );
+  }
+  async repositoryForRoot(repoRoot) {
+    const filePath = this.rootMappingPath(repoRoot);
+    try {
+      const value = z.object({
+        repository: LocalCiRepositoryIdentitySchema,
+        repoRoot: z.string().min(1)
+      }).parse(JSON.parse(await readFile(filePath, "utf8")));
+      return path4.resolve(value.repoRoot) === path4.resolve(repoRoot) ? value.repository : null;
+    } catch (error) {
+      if (isNodeErrorCode(error, "ENOENT")) return null;
+      throw stateReadError(filePath, error);
+    }
+  }
+  async create(record) {
+    const parsed = LocalCiRunRecordSchema.parse(record);
+    const filePath = this.filePath(parsed.repository, parsed.sha);
+    return this.withRecordMutationLock(parsed.repository, parsed.sha, async (fence) => {
+      await fence.assertOwned();
+      await mkdir(path4.dirname(filePath), { recursive: true, mode: 448 });
+      const temporary = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+      await writeFile(temporary, `${JSON.stringify(parsed, null, 2)}
+`, {
+        encoding: "utf8",
+        mode: 384
+      });
+      try {
+        await fence.assertOwned();
+        await access(filePath);
+        await unlink(temporary).catch(() => void 0);
+        return {
+          created: false,
+          record: await this.readUnlocked(parsed.repository, parsed.sha),
+          filePath
+        };
+      } catch (error) {
+        if (!isNodeErrorCode(error, "ENOENT")) {
+          await unlink(temporary).catch(() => void 0);
+          throw error;
+        }
+      }
+      const attemptId = beginHostPublicationGenerationJournal(parsed);
+      try {
+        await fence.assertOwned();
+        await link(temporary, filePath);
+        await unlink(temporary).catch(() => void 0);
+      } catch (error) {
+        abandonHostPublicationGenerationJournal(parsed, attemptId);
+        await unlink(temporary).catch(() => void 0);
+        if (!isNodeErrorCode(error, "EEXIST")) throw error;
+        return {
+          created: false,
+          record: await this.readUnlocked(parsed.repository, parsed.sha),
+          filePath
+        };
+      }
+      syncHostPublicationGeneration(parsed, attemptId);
+      return { created: true, record: parsed, filePath };
+    });
+  }
+  async read(repository, sha) {
+    return this.readUnlocked(repository, sha);
+  }
+  /**
+   * Read the durable record and apply any leftover host-generation journal
+   * under the per-record mutation lock so a concurrent writer cannot activate
+   * a newer obligation that this reader then retires.
+   */
+  async readAndRecover(repository, sha) {
+    return this.withRecordMutationLock(repository, sha, async (fence) => {
+      await fence.assertOwned();
+      const current = await this.readUnlocked(repository, sha);
+      await fence.assertOwned();
+      recoverHostPublicationGeneration(current);
+      return current;
+    });
+  }
+  async save(record) {
+    const parsed = LocalCiRunRecordSchema.parse(record);
+    return this.withRecordMutationLock(parsed.repository, parsed.sha, async (fence) => {
+      await fence.assertOwned();
+      return this.writeRecordUnlocked(parsed, fence);
+    });
+  }
+  /**
+   * Conditional save (CAS): write `next` only when the on-disk record still
+   * matches `expected` generation (status, createdAt, updatedAt, obligation).
+   * Cross-process safe under the per-record mutation lock.
+   */
+  async compareAndSave(expected, next) {
+    const expectedParsed = LocalCiRunRecordSchema.parse(expected);
+    const nextParsed = LocalCiRunRecordSchema.parse(next);
+    if (expectedParsed.repository !== nextParsed.repository || expectedParsed.sha.toLowerCase() !== nextParsed.sha.toLowerCase()) {
+      throw new Error("compareAndSave requires expected and next to share repository/sha.");
+    }
+    if (this.hooks.beforeCompareAndSave) {
+      await this.hooks.beforeCompareAndSave(expectedParsed, nextParsed);
+    }
+    return this.withRecordMutationLock(
+      expectedParsed.repository,
+      expectedParsed.sha,
+      async (fence) => {
+        await fence.assertOwned();
+        return this.compareAndWriteUnlocked(expectedParsed, nextParsed, fence);
+      }
+    );
+  }
+  /**
+   * CAS write under an already-held record mutation fence.
+   *
+   * Re-asserts ownership after the generation read and immediately before the
+   * final record rename (via {@link writeRecordUnlocked}). A predecessor that
+   * suspends after its first assertion and resumes after reclaim must fail closed
+   * rather than overwrite successor state.
+   */
+  async compareAndWriteUnlocked(expected, next, fence) {
+    await fence.assertOwned();
+    let current;
+    try {
+      current = await this.readUnlocked(expected.repository, expected.sha);
+    } catch {
+      return { applied: false, record: expected };
+    }
+    await fence.assertOwned();
+    if (!isSameLocalCiRecordGeneration(current, expected)) {
+      return { applied: false, record: current };
+    }
+    if (this.hooks.afterCompareAndWriteRead) {
+      await this.hooks.afterCompareAndWriteRead(current);
+      await fence.assertOwned();
+    }
+    const saved = await this.writeRecordUnlocked(next, fence);
+    return { applied: true, record: saved };
+  }
+  /**
+   * Hold the per-record mutation lock for a multi-step exclusive section
+   * (e.g. remote failure publish + readback + clear). Nested save/compareAndSave
+   * /deleteRetentionCandidates deadlock — use only the unlocked helpers provided
+   * to `fn`.
+   *
+   * Callers that await (remote publish/readback) must re-assert fence ownership
+   * before any further state change. Fail closed if ownership is lost.
+   */
+  async withExclusiveRecordAccess(repository, sha, fn) {
+    return this.withRecordMutationLock(repository, sha, async (fence) => {
+      await fence.assertOwned();
+      return fn({
+        read: async () => {
+          await fence.assertOwned();
+          const record = await this.readUnlocked(repository, sha);
+          await fence.assertOwned();
+          return record;
+        },
+        writeIfSameGeneration: async (expected, next) => {
+          await fence.assertOwned();
+          return this.compareAndWriteUnlocked(expected, next, fence);
+        },
+        assertOwned: () => fence.assertOwned()
+      });
+    });
+  }
+  /**
+   * Persist a spawned worker PID only when the on-disk generation still matches
+   * `expected` (the generation that authorized the spawn). Used after requeue CAS
+   * so a concurrent same-SHA resubmit is never overwritten with a stale PID/save.
+   */
+  async assignWorkerPid(expected, pid, pidIdentity) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+      throw new Error("assignWorkerPid requires a positive integer pid.");
+    }
+    if (pidIdentity.trim().length === 0) {
+      throw new Error("assignWorkerPid requires a process identity.");
+    }
+    const next = {
+      ...expected,
+      pid,
+      pidIdentity,
+      status: "queued",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return this.compareAndSave(expected, next);
+  }
+  async list(repository) {
+    const directory = this.repositoryDirectory(repository);
+    let entries;
+    try {
+      const { readdir } = await import("fs/promises");
+      entries = await readdir(directory);
+    } catch (error) {
+      if (isNodeErrorCode(error, "ENOENT")) return [];
+      throw error;
+    }
+    const records = [];
+    for (const entry of entries.filter((value) => value.endsWith(".json")).sort()) {
+      const sha = entry.slice(0, -".json".length);
+      if (!/^[a-f0-9]{40}$/i.test(sha)) continue;
+      try {
+        records.push(await this.read(repository, sha));
+      } catch (error) {
+        if (error instanceof Error && isNodeErrorCode(error.cause, "ENOENT")) continue;
+        throw error;
+      }
+    }
+    return records.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+  }
+  async listQueuedForBranch(repository, branch) {
+    const records = await this.list(repository);
+    return records.filter((record) => record.branch === branch && record.status === "queued").sort(compareSubmissionsNewestFirst);
+  }
+  async supersedeOlderQueued(input) {
+    const newerSha = input.newerSha.toLowerCase();
+    const updatedAt = (input.now ?? /* @__PURE__ */ new Date()).toISOString();
+    const queued = await this.listQueuedForBranch(input.repository, input.branch);
+    const newerRecord = queued.find((record) => record.sha === newerSha);
+    const superseded = [];
+    for (const candidate of queued) {
+      if (candidate.sha === newerSha) continue;
+      if (newerRecord) {
+        const ordering = compareSubmissionsNewestFirst(candidate, newerRecord);
+        if (ordering <= 0) continue;
+      }
+      let current;
+      try {
+        current = await this.read(input.repository, candidate.sha);
+      } catch {
+        continue;
+      }
+      if (current.status !== "queued") continue;
+      if (current.branch !== input.branch) continue;
+      const next = {
+        ...current,
+        status: "superseded",
+        updatedAt
+      };
+      const saved = await this.save(next);
+      superseded.push(saved);
+    }
+    return superseded;
+  }
+  /**
+   * Count consecutive terminal `failed` runs for a branch, newest submission
+   * first. A success-family terminal run (validation passed) resets the count;
+   * active runs, `superseded`/`skipped` runs and infrastructure-classified
+   * failures carry no validation verdict and are ignored. Derived from on-disk records on every call so the count cannot
+   * drift; the terminal retention window (newest-first, obligations held)
+   * always preserves enough history for this small threshold.
+   */
+  async countConsecutiveTerminalFailures(repository, branch) {
+    const records = await this.list(repository);
+    const sameBranch = records.filter((record) => record.branch === branch).sort(compareSubmissionsNewestFirst);
+    const failedShas = [];
+    for (const record of sameBranch) {
+      if (isLocalCiActiveStatus(record.status)) continue;
+      if (record.status === "superseded" || record.status === "skipped") continue;
+      if (record.status === "failed" && record.failureClass === "infrastructure") continue;
+      if (record.status === "failed") {
+        failedShas.push(record.sha);
+        continue;
+      }
+      break;
+    }
+    return { count: failedShas.length, failedShas };
+  }
+  async hasNewerSubmission(input) {
+    const sha = input.sha.toLowerCase();
+    const submittedAt = input.submittedAt ?? input.createdAt;
+    const records = await this.list(input.repository);
+    const sameBranch = records.filter((record) => record.branch === input.branch);
+    for (const record of sameBranch) {
+      const candidateSubmittedAt = submissionTime(record);
+      if (record.sha === sha && candidateSubmittedAt === submittedAt) continue;
+      if (candidateSubmittedAt > submittedAt) return true;
+      if (candidateSubmittedAt === submittedAt && record.sha !== sha) {
+        if (record.sha.localeCompare(sha) > 0) return true;
+      }
+    }
+    return false;
+  }
+  async toRetentionCandidate(record) {
+    const recordPath = this.filePath(record.repository, record.sha);
+    const logPath = this.logPath(record.repository, record.sha);
+    let logExists = false;
+    try {
+      await access(logPath);
+      logExists = true;
+    } catch {
+      logExists = false;
+    }
+    return { record, recordPath, logPath, logExists };
+  }
+  /**
+   * Select terminal records to preserve vs delete under a global terminal cap.
+   *
+   * Active (queued/running) records are always preserved and never count toward
+   * the terminal cap. Records with an outstanding remote-status publication or
+   * retained-worktree cleanup obligation are always preserved and never count
+   * toward the terminal cap.
+   * Among remaining terminal records, keep the newest globally up to
+   * `maxTerminalRecords` (default {@link DEFAULT_LOCAL_CI_MAX_TERMINAL_RECORDS});
+   * older free terminals are deletable regardless of historical branch count.
+   */
+  async selectTerminalRetention(repository, options) {
+    const records = await this.list(repository);
+    if (records.length === 0) {
+      return { preserve: [], deletable: [] };
+    }
+    const activeRecords = records.filter((record) => isLocalCiActiveStatus(record.status));
+    const terminalRecords = records.filter((record) => isLocalCiTerminalStatus(record.status)).sort(compareRecordsNewestFirst);
+    const obligationHeld = terminalRecords.filter(
+      (record) => hasOutstandingRemoteStatusPublication(record) || record.worktreePath !== void 0
+    );
+    const freeTerminals = terminalRecords.filter(
+      (record) => !hasOutstandingRemoteStatusPublication(record) && record.worktreePath === void 0
+    );
+    const maxTerminal = resolveMaxTerminalRecords(options?.maxTerminalRecords);
+    const preserveTerminals = [...obligationHeld, ...freeTerminals.slice(0, maxTerminal)];
+    const deletableRecords = freeTerminals.slice(maxTerminal);
+    const preserveRecords = [...activeRecords, ...preserveTerminals];
+    const [preserve, deletable] = await Promise.all([
+      Promise.all(preserveRecords.map((record) => this.toRetentionCandidate(record))),
+      Promise.all(deletableRecords.map((record) => this.toRetentionCandidate(record)))
+    ]);
+    return { preserve, deletable };
+  }
+  async deleteRetentionCandidates(candidates) {
+    const deletedRecords = [];
+    const deletedLogs = [];
+    const rootResolved = path4.resolve(this.root);
+    for (const candidate of candidates) {
+      const selected = candidate.record;
+      const recordPath = this.filePath(selected.repository, selected.sha);
+      const logPath = this.logPath(selected.repository, selected.sha);
+      if (!isPathUnderRoot(rootResolved, recordPath) || !isPathUnderRoot(rootResolved, logPath)) {
+        continue;
+      }
+      const deleted = await this.withRecordMutationLock(
+        selected.repository,
+        selected.sha,
+        async (fence) => {
+          await fence.assertOwned();
+          let current;
+          try {
+            current = await this.readUnlocked(selected.repository, selected.sha);
+          } catch {
+            return false;
+          }
+          await fence.assertOwned();
+          if (isLocalCiActiveStatus(current.status)) return false;
+          if (!isLocalCiTerminalStatus(current.status)) return false;
+          if (hasOutstandingRemoteStatusPublication(current)) return false;
+          if (current.worktreePath !== void 0) return false;
+          if (current.repository !== selected.repository || current.sha !== selected.sha || current.status !== selected.status || current.updatedAt !== selected.updatedAt || current.createdAt !== selected.createdAt) {
+            return false;
+          }
+          if (this.hooks.afterRetentionDeleteCheck) {
+            await this.hooks.afterRetentionDeleteCheck(current);
+            await fence.assertOwned();
+            try {
+              current = await this.readUnlocked(selected.repository, selected.sha);
+            } catch {
+              return false;
+            }
+            await fence.assertOwned();
+            if (isLocalCiActiveStatus(current.status)) return false;
+            if (!isLocalCiTerminalStatus(current.status)) return false;
+            if (hasOutstandingRemoteStatusPublication(current)) return false;
+            if (current.worktreePath !== void 0) return false;
+            if (current.repository !== selected.repository || current.sha !== selected.sha || current.status !== selected.status || current.updatedAt !== selected.updatedAt || current.createdAt !== selected.createdAt) {
+              return false;
+            }
+          }
+          await fence.assertOwned();
+          try {
+            await unlink(recordPath);
+            deletedRecords.push(recordPath);
+          } catch (error) {
+            if (!isNodeErrorCode(error, "ENOENT")) throw error;
+          }
+          await fence.assertOwned();
+          try {
+            await unlink(logPath);
+            deletedLogs.push(logPath);
+          } catch (error) {
+            if (!isNodeErrorCode(error, "ENOENT")) throw error;
+          }
+          return true;
+        }
+      );
+      void deleted;
+    }
+    return { deletedRecords, deletedLogs };
+  }
+};
+function selectCommandsForLocalCi(input) {
+  const candidates = input.explicit?.length ? input.explicit : input.resolved.map((entry) => entry.command);
+  const seen = /* @__PURE__ */ new Set();
+  const commands = [];
+  for (const candidate of candidates) {
+    const command = candidate.trim();
+    if (!command || seen.has(command)) continue;
+    seen.add(command);
+    commands.push(command);
+  }
+  return commands;
+}
+
+export {
+  NODE_PACKAGE_MANAGER_MANIFESTS,
+  launcherManifests,
+  pinnedManifestFiles,
+  referencedTableScript,
+  scopedPinKey,
+  parseScopedPin,
+  scriptTableUnchanged,
+  ENTRYPOINT_FINGERPRINT_PATTERN,
+  computeEntrypointFingerprint,
+  DEFAULT_LOCAL_CI_STATUS_CONTEXT,
+  DEFAULT_LOCAL_CI_MAX_CONCURRENT,
+  MAX_LOCAL_CI_RETAINED_LOG_BYTES,
+  boundLocalCiCommandOutput,
+  renderBoundedLocalCiLogEntry,
+  parseLocalCiRepositoryIdentity,
+  hasOutstandingRemoteStatusPublication,
+  isPublicationPending,
+  outstandingStatusPublicationMatchesRecord,
+  hasLiveFailurePublicationLease,
+  createFailurePublicationLease,
+  matchesFailurePublicationLease,
+  createOutstandingStatusPublication,
+  createOutstandingFailureStatusPublication,
+  DEFAULT_LOCAL_CI_MAX_TERMINAL_RECORDS,
+  createQueuedRun,
+  repoStateKey,
+  LocalCiStateStore,
+  selectCommandsForLocalCi
+};
+//# sourceMappingURL=chunk-VBENAHDA.js.map