@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-ZVVD2XGV.js

@@ -0,0 +1,1369 @@
+import {
+  getWorkflowLastActivityMs
+} from "./chunk-6TRD7TEE.js";
+import {
+  getBranchCleanupQueuePath,
+  readBranchCleanupQueue,
+  removeBranchCleanupEntries
+} from "./chunk-MULMXX4V.js";
+import {
+  parseGitWorktreeBranches
+} from "./chunk-UTDEOPKV.js";
+import {
+  parseJsonWithContext
+} from "./chunk-P6SSWAKY.js";
+import {
+  isEphemeralBuildBranchDeletionCandidate,
+  isProtectedPipelineBranch,
+  parseCurrentBranchRef,
+  resolveDefaultBranch
+} from "./chunk-XGU6PBO5.js";
+import {
+  buildRemovedBranchName,
+  buildVariantBranchPrefixes,
+  findBuildBranchShape,
+  isBuildOwnedBranch,
+  isValidationBranch,
+  runBranchNameCandidates,
+  runChildBranchTargets
+} from "./chunk-F55YABKV.js";
+import {
+  resolveRunStateDir,
+  resolveRunStateReadDirs
+} from "./chunk-AJN5Y5YZ.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import {
+  resolveBuildDirFromContext
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/cleanup/branch-cleanup-manager.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve4 } from "path";
+import { execa as execa2 } from "execa";
+
+// src/core/git/cleanup-current-branch.ts
+import { execa } from "execa";
+var CLEANUP_UNBORN_REPOSITORY_INFO = "Info: repository has no commits yet";
+var CLEANUP_HEAD_INSPECTION_ERROR = "Error: could not inspect repository HEAD";
+var AMBIGUOUS_HEAD_SIGNATURE = /ambiguous argument ['"]HEAD['"]/i;
+var UNKNOWN_REVISION_SIGNATURE = /unknown revision|bad object/i;
+function isAmbiguousHeadFailure(stderr, stdout) {
+  const combined = `${stderr}
+${stdout}`;
+  return AMBIGUOUS_HEAD_SIGNATURE.test(combined);
+}
+function isUnknownRevisionFailure(stderr, stdout) {
+  const combined = `${stderr}
+${stdout}`;
+  return UNKNOWN_REVISION_SIGNATURE.test(combined);
+}
+async function headCommitIsMissing(cwd) {
+  const verify = await execa("git", ["rev-parse", "--verify", "-q", "HEAD^{commit}"], {
+    cwd,
+    reject: false,
+    stdio: "pipe"
+  });
+  const exitCode = verify.exitCode ?? 0;
+  if (exitCode === 0) {
+    return false;
+  }
+  return isUnknownRevisionFailure(verify.stderr ?? "", verify.stdout ?? "");
+}
+async function resolveCleanupCurrentBranch(cwd) {
+  const revParse = await execa("git", ["rev-parse", "--symbolic-full-name", "HEAD"], {
+    cwd,
+    reject: false,
+    stdio: "pipe"
+  });
+  const revParseExitCode = revParse.exitCode ?? 0;
+  if (revParseExitCode === 0) {
+    const branch = revParse.stdout.trim() ? parseCurrentBranchRef(revParse.stdout) : "";
+    if (branch === "HEAD") {
+      return { state: "detached" };
+    }
+    if (branch) {
+      return { state: "attached", branch };
+    }
+  }
+  const revParseAmbiguous = revParseExitCode !== 0 && isAmbiguousHeadFailure(revParse.stderr ?? "", revParse.stdout ?? "");
+  const symbolic = await execa("git", ["symbolic-ref", "--quiet", "--short", "HEAD"], {
+    cwd,
+    reject: false,
+    stdio: "pipe"
+  });
+  const symbolicExitCode = symbolic.exitCode ?? 0;
+  if (symbolicExitCode === 0) {
+    const symbolicBranch = symbolic.stdout.trim();
+    if (symbolicBranch) {
+      if (revParseAmbiguous) {
+        return { state: "unborn", symbolicBranch };
+      }
+      if (revParseExitCode !== 0 && await headCommitIsMissing(cwd)) {
+        return { state: "unborn", symbolicBranch };
+      }
+    }
+  }
+  if (revParseAmbiguous) {
+    const fallbackSymbolic = await execa("git", ["symbolic-ref", "--short", "HEAD"], {
+      cwd,
+      reject: false,
+      stdio: "pipe"
+    });
+    const branch = fallbackSymbolic.stdout.trim();
+    if ((fallbackSymbolic.exitCode ?? 0) === 0 && branch) {
+      return { state: "unborn", symbolicBranch: branch };
+    }
+  }
+  if (revParseExitCode !== 0) {
+    return { state: "unknown", reason: "HEAD branch inspection failed" };
+  }
+  return { state: "detached" };
+}
+
+// src/core/cleanup/tool-branch-cleanup.ts
+import { existsSync } from "fs";
+import { readdir, readFile as readFile2, realpath, stat as stat2 } from "fs/promises";
+import { join, resolve as resolve3 } from "path";
+
+// src/core/cleanup/competition-state-cleanup.ts
+import { opendir, readFile, rm, stat } from "fs/promises";
+import { resolve as resolve2 } from "path";
+
+// src/core/cleanup/state-dir.ts
+import { resolve } from "path";
+function resolveCleanupBuildDir(cwd) {
+  return cwd ? resolve(cwd, ".build-project") : resolveBuildDirFromContext();
+}
+
+// src/core/cleanup/competition-state-cleanup.ts
+function parseIsoDateMs(value) {
+  if (!value) return null;
+  const ms = new Date(value).getTime();
+  if (!Number.isFinite(ms)) return null;
+  return ms;
+}
+function isTerminalCandidate(candidate) {
+  if (candidate.submittedOnly === true) return false;
+  if (typeof candidate.success === "boolean") return true;
+  if (candidate.timedOut === true) return true;
+  if (typeof candidate.errorMessage === "string" && candidate.errorMessage.trim().length > 0) {
+    return true;
+  }
+  return false;
+}
+function getHandleCandidates(handle) {
+  if (Array.isArray(handle.candidates)) return handle.candidates;
+  if (Array.isArray(handle.variants)) return handle.variants;
+  return [];
+}
+function isTerminalHandle(handle) {
+  const candidates = getHandleCandidates(handle);
+  if (candidates.length === 0) return false;
+  return candidates.every(isTerminalCandidate);
+}
+function describeNonTerminalMetadata(handle) {
+  const candidates = getHandleCandidates(handle);
+  const hasSubmittedOnly = candidates.length > 0 && candidates.every((candidate) => candidate.submittedOnly === true);
+  const hasStatusFields = candidates.some((candidate) => {
+    if (typeof candidate.success === "boolean") return true;
+    if (candidate.timedOut === true) return true;
+    if (typeof candidate.errorMessage === "string" && candidate.errorMessage.trim().length > 0) {
+      return true;
+    }
+    return false;
+  });
+  return {
+    hasSubmittedOnly,
+    hasStatusFields
+  };
+}
+function evaluateNonTerminalState(ageMs, metadata, policy) {
+  if (policy === "strict") {
+    return { keep: true, reason: "non_terminal" };
+  }
+  const hours = ageMs / (60 * 60 * 1e3);
+  const days = ageMs / (24 * 60 * 60 * 1e3);
+  if (days >= 30) {
+    return { keep: false, reason: "non_terminal_stale" };
+  }
+  if (metadata.hasSubmittedOnly && days >= 7) {
+    return { keep: false, reason: "non_terminal_submitted_expired" };
+  }
+  if (metadata.hasSubmittedOnly && hours >= 48) {
+    return { keep: true, reason: "non_terminal_submitted_grace" };
+  }
+  if (!metadata.hasStatusFields && hours >= 48) {
+    return { keep: false, reason: "non_terminal_missing_status" };
+  }
+  return { keep: true, reason: "non_terminal" };
+}
+async function cleanupCompetitionStateFiles(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const rootDir = resolve2(resolveRunStateDir(resolveCleanupBuildDir(options.cwd)), "competitions");
+  const maxAgeMs = options.maxAgeDays * 24 * 60 * 60 * 1e3;
+  const report = {
+    mode: options.dryRun ? "dry-run" : "executed",
+    rootDir,
+    scanned: 0,
+    eligible: 0,
+    deleted: 0,
+    kept: 0,
+    freedBytes: 0,
+    keptBecause: {},
+    deletedBecause: {},
+    items: [],
+    errors: []
+  };
+  const bump = (map, key) => {
+    map[key] = (map[key] ?? 0) + 1;
+  };
+  const entries = [];
+  try {
+    const dir = await opendir(rootDir);
+    try {
+      for await (const d of dir) {
+        if (!d.isFile()) continue;
+        if (!d.name.endsWith(".json")) continue;
+        const fullPath = resolve2(rootDir, d.name);
+        report.scanned++;
+        try {
+          const st = await stat(fullPath);
+          const sizeBytes = st.size;
+          const tsMsFromStat = st.mtimeMs;
+          const raw = await readFile(fullPath, "utf8");
+          let parsed;
+          try {
+            parsed = parseJsonWithContext(raw, `Competition state (${d.name})`);
+          } catch {
+            const ageDays = Math.floor((now.getTime() - tsMsFromStat) / (24 * 60 * 60 * 1e3));
+            bump(report.keptBecause, "invalid_json");
+            report.kept++;
+            report.items.push({
+              path: fullPath,
+              sizeBytes,
+              ageDays,
+              terminal: false,
+              decision: "keep",
+              reason: "invalid_json"
+            });
+            continue;
+          }
+          const updatedMs = parseIsoDateMs(parsed.updatedAt) ?? parseIsoDateMs(parsed.createdAt);
+          const terminal = isTerminalHandle(parsed);
+          const metadata = describeNonTerminalMetadata(parsed);
+          entries.push({
+            name: d.name,
+            fullPath,
+            sizeBytes,
+            tsMs: updatedMs ?? tsMsFromStat,
+            terminal,
+            metadata
+          });
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          report.errors.push(`${d.name}: stat/read failed: ${msg}`);
+          bump(report.keptBecause, "read_error");
+          report.kept++;
+          report.items.push({
+            path: fullPath,
+            sizeBytes: 0,
+            ageDays: 0,
+            terminal: false,
+            decision: "keep",
+            reason: "read_error"
+          });
+        }
+      }
+    } finally {
+      await dir.close().catch(() => {
+      });
+    }
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    report.errors.push(`Failed to read ${rootDir}: ${msg}`);
+    return report;
+  }
+  const keepLast = Math.max(0, options.keepLast);
+  const keepLastSet = /* @__PURE__ */ new Set();
+  if (keepLast > 0) {
+    const sorted = [...entries].sort((a, b) => b.tsMs - a.tsMs);
+    for (const e of sorted.slice(0, keepLast)) {
+      keepLastSet.add(e.fullPath);
+    }
+  }
+  for (const entry of entries) {
+    const ageMs = now.getTime() - entry.tsMs;
+    const ageDays = Math.floor(ageMs / (24 * 60 * 60 * 1e3));
+    const terminal = entry.terminal;
+    const metadata = entry.metadata;
+    const policy = options.nonTerminalPolicy ?? (options.keepNonTerminal ? "strict" : "smart");
+    const isTooOld = ageMs > maxAgeMs;
+    let decision = "keep";
+    let reason = "too_recent";
+    if (keepLastSet.has(entry.fullPath)) {
+      decision = "keep";
+      reason = "keep_last";
+      bump(report.keptBecause, reason);
+    } else if (!isTooOld) {
+      decision = "keep";
+      reason = "too_recent";
+      bump(report.keptBecause, reason);
+    } else if (!terminal) {
+      const disposition = evaluateNonTerminalState(ageMs, metadata, policy);
+      if (disposition.keep) {
+        decision = "keep";
+        reason = disposition.reason;
+        bump(report.keptBecause, reason);
+      } else {
+        decision = "delete";
+        reason = disposition.reason;
+        bump(report.deletedBecause, reason);
+      }
+    } else {
+      decision = "delete";
+      reason = "stale_terminal";
+      bump(report.deletedBecause, reason);
+    }
+    if (decision === "delete") {
+      report.eligible++;
+      if (options.dryRun) {
+        report.freedBytes += entry.sizeBytes;
+      } else {
+        try {
+          await rm(entry.fullPath, { force: true });
+          const eventsPath = entry.fullPath.replace(/\.json$/, ".events.jsonl");
+          await rm(eventsPath, { force: true }).catch(() => {
+          });
+          report.deleted++;
+          report.freedBytes += entry.sizeBytes;
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          report.errors.push(`${entry.name}: delete failed: ${msg}`);
+          decision = "keep";
+          reason = "read_error";
+          bump(report.keptBecause, reason);
+        }
+      }
+    }
+    if (decision === "keep") report.kept++;
+    report.items.push({
+      path: entry.fullPath,
+      sizeBytes: entry.sizeBytes,
+      ageDays,
+      terminal,
+      decision,
+      reason
+    });
+  }
+  if (options.dryRun) {
+    report.deleted = report.eligible;
+  }
+  if (!options.verbose) {
+    report.items = report.items.slice(0, 200);
+  }
+  return report;
+}
+
+// src/core/cleanup/tool-branch-cleanup.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var UNFINISHED_RUN_PROTECTION_DAYS = 30;
+var NON_RUN_FLYWHEEL_ENTRIES = /* @__PURE__ */ new Set(["legacy-archive", "detached", "cache"]);
+async function listEntries(dir) {
+  try {
+    return await readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+async function listCheckoutRoots(repoRoot) {
+  const paths = [repoRoot];
+  try {
+    const result = await execGit(["worktree", "list", "--porcelain"], { cwd: repoRoot });
+    if (result.exitCode === 0) {
+      paths.push(...parseGitWorktreeBranches(result.stdout).map((entry) => entry.path));
+    }
+  } catch {
+  }
+  const roots = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const key = await realpath(p).catch(() => resolve3(p));
+    if (!roots.has(key)) roots.set(key, p);
+  }
+  return [...roots.values()];
+}
+async function loadRunBranchGuard(repoRoot, now = Date.now()) {
+  const exact = /* @__PURE__ */ new Map();
+  const prefixes = [];
+  const isRecent = async (recordedMs, file) => {
+    const activityMs = Number.isFinite(recordedMs) ? recordedMs : await stat2(file).then(
+      (st) => st.mtimeMs,
+      () => Number.NaN
+    );
+    return !(now - activityMs > UNFINISHED_RUN_PROTECTION_DAYS * DAY_MS);
+  };
+  for (const checkoutRoot of await listCheckoutRoots(repoRoot)) {
+    const flywheelDir = join(checkoutRoot, ".build-project", "tmp", "flywheel");
+    for (const entry of await listEntries(flywheelDir)) {
+      if (!entry.isDirectory() || NON_RUN_FLYWHEEL_ENTRIES.has(entry.name)) continue;
+      const manifestPath = join(flywheelDir, entry.name, "manifest.json");
+      if (!existsSync(manifestPath)) continue;
+      let manifest;
+      try {
+        manifest = JSON.parse(await readFile2(manifestPath, "utf8"));
+      } catch {
+      }
+      if (manifest?.appliedAt) continue;
+      const recordedMs = manifest ? getWorkflowLastActivityMs(manifest) : void 0;
+      if (!await isRecent(recordedMs, manifestPath)) continue;
+      const reason = `unfinished run ${entry.name}`;
+      const gathering = new Set(runBranchNameCandidates(entry.name));
+      if (typeof manifest?.integrationBranch === "string" && manifest.integrationBranch) {
+        gathering.add(manifest.integrationBranch);
+      }
+      for (const name of gathering) {
+        exact.set(name, reason);
+        const children = runChildBranchTargets(name);
+        for (const child of children.exact) exact.set(child, reason);
+        for (const prefix of children.prefixes) prefixes.push([prefix, reason]);
+      }
+    }
+  }
+  let stateDirs = [];
+  try {
+    stateDirs = resolveRunStateReadDirs(join(repoRoot, ".build-project"));
+  } catch {
+  }
+  for (const stateDir of stateDirs) {
+    const dir = join(stateDir, "competitions");
+    for (const entry of await listEntries(dir)) {
+      if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+      try {
+        const handlePath = join(dir, entry.name);
+        const handle = JSON.parse(await readFile2(handlePath, "utf8"));
+        if (typeof handle?.taskId !== "string" || isTerminalHandle(handle)) continue;
+        if (!await isRecent(Date.parse(handle.updatedAt ?? ""), handlePath)) continue;
+        for (const prefix of buildVariantBranchPrefixes(handle.taskId)) {
+          prefixes.push([prefix, `unfinished competition ${handle.taskId}`]);
+        }
+      } catch {
+      }
+    }
+  }
+  return (branch) => exact.get(branch) ?? prefixes.find(([prefix]) => branch.startsWith(prefix))?.[1];
+}
+async function analyzeToolBranch(manager, branch, queuedEntry, opts, runGuard) {
+  const unfinished = runGuard(branch);
+  if (unfinished) {
+    return { name: branch, action: "skip", reason: unfinished };
+  }
+  const currentHeadSha = await manager.getBranchHeadSha(branch) ?? void 0;
+  if (!currentHeadSha) {
+    return { name: branch, action: "skip", reason: "branch head unavailable" };
+  }
+  const expectedHeadSha = queuedEntry?.expectedHeadSha;
+  if (expectedHeadSha && expectedHeadSha === currentHeadSha) {
+    return {
+      name: branch,
+      action: "archive",
+      reason: "queued worktree cleanup",
+      details: { queuedForCleanup: true, expectedHeadSha, currentHeadSha }
+    };
+  }
+  const now = opts.now ?? Date.now();
+  const thresholdMs = opts.minAgeDays * DAY_MS;
+  const lastActivity = await manager.getLastActivityTime(branch, thresholdMs, now);
+  const idleMs = now - lastActivity.getTime();
+  const ageDays = Math.floor(idleMs / DAY_MS);
+  const details = {
+    ageDays,
+    lastActivity,
+    queuedForCleanup: Boolean(queuedEntry),
+    expectedHeadSha,
+    currentHeadSha
+  };
+  if (idleMs < thresholdMs) {
+    const queuedNote = expectedHeadSha ? "; queued branch head changed" : "";
+    return {
+      name: branch,
+      action: "skip",
+      reason: `active ${ageDays}d ago (threshold: ${opts.minAgeDays}d)${queuedNote}`,
+      details
+    };
+  }
+  return { name: branch, action: "archive", reason: "idle", details };
+}
+
+// src/core/cleanup/branch-cleanup-manager.ts
+var DEFAULT_BRANCH_CLEANUP_AGE_DAYS = 7;
+var STRICT_BUILD_PATTERNS = [
+  // Legacy lab mode worktree branches (before build/wt-*, now build/lab/*)
+  /^lab-[a-f0-9]{8,}-\d{14,}-.*-[a-f0-9]{8}$/,
+  // Backup branches (numeric timestamp)
+  /^backup\/pre-sync-\d{10,}$/,
+  // Legacy Build competition branches (feature/<uuid>-...-<8hex>)
+  /^feature\/[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}-.*-[a-f0-9]{8}$/i
+];
+var EXTENDED_TEST_PATTERNS = [
+  // Test harness branches (require 8-char hex suffix)
+  /^feature\/task-\d+-.*-[a-f0-9]{8}$/,
+  /^feature\/test-\d+-variant-.*-[a-f0-9]{8}$/
+];
+var BranchCleanupManager = class {
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+  }
+  cwd;
+  defaultBranch = null;
+  remoteDefaultBranches = /* @__PURE__ */ new Map();
+  queuedBranches = /* @__PURE__ */ new Map();
+  runGuard;
+  async refreshQueuedBranches() {
+    try {
+      const entries = await readBranchCleanupQueue(getBranchCleanupQueuePath(this.cwd));
+      this.queuedBranches = new Map(entries.map((entry) => [entry.branch, entry]));
+    } catch {
+      this.queuedBranches = /* @__PURE__ */ new Map();
+    }
+  }
+  /**
+   * Auto-detect the default branch from origin/HEAD or fallback.
+   * Delegates to resolveDefaultBranch; caches the result on this instance.
+   */
+  async getDefaultBranch() {
+    if (this.defaultBranch) {
+      return this.defaultBranch;
+    }
+    this.defaultBranch = await resolveDefaultBranch(this.cwd);
+    return this.defaultBranch;
+  }
+  /**
+   * Auto-detect the default branch for a specific remote (e.g. origin/HEAD, upstream/HEAD).
+   * Falls back to getDefaultBranch() if the remote HEAD cannot be resolved.
+   */
+  async getDefaultBranchForRemote(remote) {
+    const cached = this.remoteDefaultBranches.get(remote);
+    if (cached) return cached;
+    try {
+      const { stdout } = await execa2("git", ["symbolic-ref", `refs/remotes/${remote}/HEAD`], {
+        cwd: this.cwd,
+        stdio: "pipe"
+      });
+      const prefix = `refs/remotes/${remote}/`;
+      const trimmed = stdout.trim();
+      if (trimmed.startsWith(prefix)) {
+        const branch = trimmed.slice(prefix.length);
+        if (branch.length > 0) {
+          this.remoteDefaultBranches.set(remote, branch);
+          return branch;
+        }
+      }
+    } catch {
+    }
+    return await this.getDefaultBranch();
+  }
+  /**
+   * Get current HEAD branch name for cleanup analysis.
+   *
+   * Returns "HEAD" when detached. Never throws for unborn repositories.
+   */
+  async getCurrentBranch() {
+    const resolution = await resolveCleanupCurrentBranch(this.cwd);
+    if (resolution.state === "attached") {
+      return resolution.branch;
+    }
+    if (resolution.state === "unborn") {
+      return resolution.symbolicBranch;
+    }
+    return "HEAD";
+  }
+  /** Get all worktree-attached branches */
+  async getWorktreeBranches() {
+    const branches = /* @__PURE__ */ new Map();
+    const { stdout } = await execa2("git", ["worktree", "list", "--porcelain"], {
+      cwd: this.cwd,
+      stdio: "pipe"
+    });
+    const lines = stdout.split("\n");
+    let currentPath = null;
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) {
+        currentPath = resolve4(line.substring("worktree ".length).trim());
+      } else if (line.startsWith("branch ") && currentPath) {
+        const branchRef = line.substring("branch ".length).trim();
+        const branchName = branchRef.replace(/^refs\/heads\//, "");
+        branches.set(branchName, currentPath);
+        currentPath = null;
+      }
+    }
+    return branches;
+  }
+  /**
+   * Check if a remote ref exists for this branch (local remote-tracking refs)
+   */
+  async hasRemoteRef(branch) {
+    try {
+      const { stdout } = await execa2(
+        "git",
+        ["for-each-ref", "--format=%(refname:short)", `refs/remotes/*/${branch}`],
+        { cwd: this.cwd, stdio: "pipe" }
+      );
+      const refs = stdout.trim().split("\n").filter(Boolean);
+      return refs[0] || null;
+    } catch {
+      return null;
+    }
+  }
+  /** Check if branch has upstream tracking configured */
+  async hasUpstreamTracking(branch) {
+    try {
+      const { stdout } = await execa2("git", ["config", "--get", `branch.${branch}.remote`], {
+        cwd: this.cwd,
+        stdio: "pipe"
+      });
+      const remote = stdout.trim();
+      if (remote) {
+        const { stdout: merge } = await execa2(
+          "git",
+          ["config", "--get", `branch.${branch}.merge`],
+          { cwd: this.cwd, stdio: "pipe" }
+        );
+        return `${remote}/${merge.replace("refs/heads/", "")}`;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Check if branch is merged into default branch using merge-base --is-ancestor
+   * This is more reliable than git branch -d behavior
+   */
+  async isMergedInto(branch, target) {
+    try {
+      await execa2("git", ["merge-base", "--is-ancestor", branch, target], {
+        cwd: this.cwd,
+        stdio: "pipe"
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get count of commits ahead of default branch (unique commits)
+   */
+  async getAheadCount(branch, target) {
+    try {
+      const { stdout } = await execa2("git", ["rev-list", "--count", `${target}..${branch}`], {
+        cwd: this.cwd,
+        stdio: "pipe"
+      });
+      return parseInt(stdout.trim(), 10) || 0;
+    } catch {
+      return 0;
+    }
+  }
+  async getBranchHeadSha(branch) {
+    try {
+      const { stdout } = await execa2(
+        "git",
+        ["rev-parse", "--verify", `refs/heads/${branch}^{commit}`],
+        {
+          cwd: this.cwd,
+          stdio: "pipe"
+        }
+      );
+      return stdout.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get last activity time for a branch
+   * Uses max of: tip commit time, reflog latest entry
+   * Conservative: if reflog missing and near threshold, treat as recent
+   */
+  async getLastActivityTime(branch, thresholdMs, now = Date.now()) {
+    let tipTime = null;
+    let reflogTime = null;
+    try {
+      const { stdout } = await execa2("git", ["show", "-s", "--format=%ct", branch], {
+        cwd: this.cwd,
+        stdio: "pipe"
+      });
+      tipTime = parseInt(stdout.trim(), 10) * 1e3;
+    } catch {
+    }
+    try {
+      const { stdout } = await execa2(
+        "git",
+        ["reflog", "show", "--date=unix", "--format=%gd", "-1", branch],
+        {
+          cwd: this.cwd,
+          stdio: "pipe"
+        }
+      );
+      const selector = stdout.trim().split("\n")[0] ?? "";
+      const timestampMatch = selector.match(/@\{(?<timestamp>\d+)\}$/);
+      const timestamp = parseInt(timestampMatch?.groups?.timestamp ?? "", 10);
+      reflogTime = Number.isFinite(timestamp) && timestamp > 0 ? timestamp * 1e3 : null;
+    } catch {
+    }
+    const lastActivity = Math.max(tipTime || 0, reflogTime || 0);
+    if (!reflogTime && tipTime) {
+      const age = now - tipTime;
+      if (age < thresholdMs * 2) {
+        return new Date(now);
+      }
+    }
+    return new Date(lastActivity || now);
+  }
+  /** Check if branch name matches any protected pattern */
+  isProtectedBranch(branch) {
+    return isProtectedPipelineBranch(branch, void 0, this.cwd);
+  }
+  /** Check if branch matches cleanup patterns */
+  matchesCleanupPattern(branch, includeTestBranches) {
+    if (isBuildOwnedBranch(branch)) {
+      return true;
+    }
+    for (const pattern of STRICT_BUILD_PATTERNS) {
+      if (pattern.test(branch)) {
+        return true;
+      }
+    }
+    if (includeTestBranches) {
+      for (const pattern of EXTENDED_TEST_PATTERNS) {
+        if (pattern.test(branch)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /** Get all local branches */
+  async getAllBranches(toolBranchesOnly = false) {
+    const { stdout } = await execa2(
+      "git",
+      [
+        "for-each-ref",
+        "--format=%(refname:short)",
+        toolBranchesOnly ? "refs/heads/build/" : "refs/heads/"
+      ],
+      { cwd: this.cwd, stdio: "pipe" }
+    );
+    const branches = stdout.trim().split("\n").filter(Boolean);
+    return toolBranchesOnly ? branches.filter(isBuildOwnedBranch) : branches;
+  }
+  /**
+   * Analyze branches for cleanup
+   * This is a read-only operation that returns what would be archived
+   */
+  async analyze(options = {}) {
+    const opts = {
+      includeBranches: options.includeBranches ?? false,
+      includeTestBranches: options.includeTestBranches ?? false,
+      dryRun: options.dryRun ?? true,
+      allowUnmerged: options.allowUnmerged ?? false,
+      confirm: options.confirm,
+      minAgeDays: options.minAgeDays ?? DEFAULT_BRANCH_CLEANUP_AGE_DAYS,
+      maxArchiveCount: options.maxArchiveCount ?? 100,
+      verbose: options.verbose ?? false,
+      toolBranchesOnly: options.toolBranchesOnly ?? false,
+      now: options.now ?? Date.now()
+    };
+    const result = {
+      mode: "dry-run",
+      // Analysis is always dry-run
+      defaultBranch: await this.getDefaultBranch(),
+      patternsUsed: opts.includeTestBranches ? "extended" : "strict",
+      scanned: 0,
+      archived: 0,
+      skipped: 0,
+      branches: [],
+      errors: [],
+      circuitBreakerTriggered: false
+    };
+    if (!opts.includeBranches) {
+      return result;
+    }
+    await this.refreshQueuedBranches();
+    this.runGuard = void 0;
+    const headResolution = await resolveCleanupCurrentBranch(this.cwd);
+    if (headResolution.state === "unknown") {
+      result.headInspectionError = true;
+      result.errors.push(CLEANUP_HEAD_INSPECTION_ERROR);
+      result.scanned = 0;
+      result.skipped = 0;
+      return result;
+    }
+    if (headResolution.state === "unborn") {
+      result.unbornRepository = true;
+      result.scanned = 0;
+      result.skipped = 0;
+      return result;
+    }
+    const branches = await this.getAllBranches(opts.toolBranchesOnly);
+    const currentBranch = headResolution.state === "attached" ? headResolution.branch : "HEAD";
+    let worktreeBranches;
+    try {
+      worktreeBranches = await this.getWorktreeBranches();
+    } catch (error) {
+      result.errors.push(
+        `Failed to inspect git worktrees; skipping branch cleanup analysis: ${error instanceof Error ? error.message : String(error)}`
+      );
+      result.scanned = branches.length;
+      result.skipped = branches.length;
+      result.branches = branches.map((branch) => ({
+        name: branch,
+        action: "skip",
+        reason: "worktree inspection unavailable"
+      }));
+      return result;
+    }
+    const thresholdMs = opts.minAgeDays * 24 * 60 * 60 * 1e3;
+    result.scanned = branches.length;
+    if (currentBranch === "HEAD") {
+      result.errors.push("Detached HEAD detected; skipping branch cleanup analysis for safety.");
+      result.skipped = branches.length;
+      result.branches = branches.map((branch) => ({
+        name: branch,
+        action: "skip",
+        reason: "detached HEAD"
+      }));
+      return result;
+    }
+    for (const branch of branches) {
+      if (result.archived >= opts.maxArchiveCount) {
+        result.circuitBreakerTriggered = true;
+        result.branches.push({
+          name: branch,
+          action: "skip",
+          reason: "circuit breaker triggered"
+        });
+        result.skipped++;
+        continue;
+      }
+      const analysis = await this.analyzeBranch(
+        branch,
+        currentBranch,
+        worktreeBranches,
+        result.defaultBranch,
+        thresholdMs,
+        opts,
+        this.queuedBranches
+      );
+      result.branches.push(analysis);
+      if (analysis.action === "archive") {
+        result.archived++;
+      } else {
+        result.skipped++;
+      }
+    }
+    return result;
+  }
+  /** Analyze a single branch */
+  async analyzeBranch(branch, currentBranch, worktreeBranches, defaultBranch, thresholdMs, opts, queuedBranches) {
+    if (this.isProtectedBranch(branch)) {
+      return { name: branch, action: "skip", reason: "protected branch" };
+    }
+    if (branch === currentBranch) {
+      return { name: branch, action: "skip", reason: "current HEAD" };
+    }
+    if (isValidationBranch(branch)) {
+      return { name: branch, action: "skip", reason: "validation branch" };
+    }
+    const worktreePath = worktreeBranches.get(branch);
+    const queuedEntry = queuedBranches.get(branch);
+    const toolBranch = isBuildOwnedBranch(branch);
+    if (worktreePath) {
+      if (toolBranch || existsSync2(worktreePath)) {
+        return {
+          name: branch,
+          action: "skip",
+          reason: `worktree: ${worktreePath}`,
+          details: { worktreePath }
+        };
+      }
+      if (!queuedEntry) {
+        return {
+          name: branch,
+          action: "skip",
+          reason: `worktree metadata present but missing on disk: ${worktreePath}`,
+          details: { worktreePath }
+        };
+      }
+    }
+    if (!toolBranch && queuedEntry?.expectedHeadSha) {
+      const currentHeadSha = await this.getBranchHeadSha(branch);
+      if (!currentHeadSha) {
+        return {
+          name: branch,
+          action: "skip",
+          reason: "queued branch head unavailable",
+          details: { expectedHeadSha: queuedEntry.expectedHeadSha }
+        };
+      }
+      if (currentHeadSha !== queuedEntry.expectedHeadSha) {
+        return {
+          name: branch,
+          action: "skip",
+          reason: "queued branch head changed",
+          details: {
+            expectedHeadSha: queuedEntry.expectedHeadSha,
+            currentHeadSha
+          }
+        };
+      }
+    }
+    const remoteRef = await this.hasRemoteRef(branch);
+    if (remoteRef) {
+      return {
+        name: branch,
+        action: "skip",
+        reason: `has remote ref: ${remoteRef}`,
+        details: { remoteBranch: remoteRef }
+      };
+    }
+    const upstream = await this.hasUpstreamTracking(branch);
+    if (upstream) {
+      return {
+        name: branch,
+        action: "skip",
+        reason: `tracks upstream: ${upstream}`,
+        details: { remoteBranch: upstream }
+      };
+    }
+    if (toolBranch) {
+      this.runGuard ??= loadRunBranchGuard(this.cwd, opts.now);
+      return analyzeToolBranch(this, branch, queuedEntry, opts, await this.runGuard);
+    }
+    if (!this.matchesCleanupPattern(branch, opts.includeTestBranches)) {
+      return { name: branch, action: "skip", reason: "no pattern match" };
+    }
+    const isMerged = await this.isMergedInto(branch, defaultBranch);
+    const aheadCount = await this.getAheadCount(branch, defaultBranch);
+    if (!isMerged || aheadCount > 0) {
+      if (!opts.allowUnmerged) {
+        return {
+          name: branch,
+          action: "skip",
+          reason: `${aheadCount} unmerged commits`,
+          details: { aheadCount }
+        };
+      }
+    }
+    const lastActivity = await this.getLastActivityTime(branch, thresholdMs, opts.now);
+    const ageDays = Math.floor(((opts.now ?? 0) - lastActivity.getTime()) / (24 * 60 * 60 * 1e3));
+    const isQueued = Boolean(queuedEntry);
+    if (!isQueued && ageDays < opts.minAgeDays) {
+      return {
+        name: branch,
+        action: "skip",
+        reason: `active ${ageDays}d ago (threshold: ${opts.minAgeDays}d)`,
+        details: { ageDays, lastActivity }
+      };
+    }
+    return {
+      name: branch,
+      action: "archive",
+      reason: isQueued ? "queued worktree cleanup" : "matches criteria",
+      details: {
+        ageDays,
+        aheadCount,
+        lastActivity,
+        queuedForCleanup: isQueued,
+        expectedHeadSha: queuedEntry?.expectedHeadSha,
+        currentHeadSha: await this.getBranchHeadSha(branch) ?? void 0
+      }
+    };
+  }
+  /** Why a move candidate changed since analysis (tip, checkout, push), or null. */
+  async changedSinceAnalysis(branch) {
+    const headSha = await this.getBranchHeadSha(branch.name);
+    if (!headSha || headSha !== branch.details?.currentHeadSha) return "tip changed since analysis";
+    if ((await this.getWorktreeBranches()).has(branch.name)) return "checked out since analysis";
+    if (await this.hasRemoteRef(branch.name) || await this.hasUpstreamTracking(branch.name)) {
+      return "pushed since analysis";
+    }
+    return null;
+  }
+  /**
+   * Move branches aside into the build/removed/<date>/ holding area
+   * Returns the actual result after execution
+   */
+  async archive(options = {}) {
+    const analysis = await this.analyze(options);
+    if (options.dryRun ?? true) {
+      return analysis;
+    }
+    const archiveCount = analysis.branches.filter((b) => b.action === "archive").length;
+    if (options.confirm !== archiveCount) {
+      analysis.errors.push(
+        `Confirmation mismatch: --confirm ${options.confirm ?? "not provided"} but ${archiveCount} branches to archive. Use --confirm ${archiveCount} to proceed.`
+      );
+      return analysis;
+    }
+    return this.executeMoves(analysis, options.now);
+  }
+  /**
+   * Move an analysis's candidates into build/removed/<UTC date>/ (no
+   * confirmation gate; callers own that). Each branch is re-checked first; a
+   * failure on one branch is recorded and the rest continue.
+   */
+  async executeMoves(analysis, now = Date.now()) {
+    analysis.mode = "executed";
+    const timestamp = new Date(now).toISOString().slice(0, 10).replace(/-/g, "");
+    const successfullyArchivedQueuedBranches = [];
+    for (const branch of analysis.branches) {
+      if (branch.action !== "archive") continue;
+      const archiveName = buildRemovedBranchName(timestamp, branch.name);
+      try {
+        const changed = await this.changedSinceAnalysis(branch);
+        if (changed) {
+          branch.action = "skip";
+          branch.reason = changed;
+          continue;
+        }
+        await execa2("git", ["branch", "-m", "--", branch.name, archiveName], {
+          cwd: this.cwd,
+          stdio: "pipe"
+        });
+        branch.reason = `moved to ${archiveName}`;
+        if (this.queuedBranches.has(branch.name)) {
+          successfullyArchivedQueuedBranches.push(branch.name);
+        }
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        analysis.errors.push(`Failed to archive ${branch.name}: ${msg}`);
+        branch.action = "skip";
+        branch.reason = `archive failed: ${msg}`;
+      }
+    }
+    analysis.archived = analysis.branches.filter((b) => b.action === "archive").length;
+    analysis.skipped = analysis.branches.filter((b) => b.action === "skip").length;
+    if (successfullyArchivedQueuedBranches.length > 0) {
+      try {
+        await removeBranchCleanupEntries(
+          successfullyArchivedQueuedBranches,
+          getBranchCleanupQueuePath(this.cwd)
+        );
+      } catch {
+      }
+    }
+    this.queuedBranches.clear();
+    return analysis;
+  }
+  // ============================================================================
+  // REMOTE BRANCH CLEANUP (Safety-first, off by default)
+  // ============================================================================
+  /**
+   * Get all remote branches matching build/* pattern
+   * SAFETY: Only returns build/* branches to prevent accidental deletion of human work
+   */
+  async getRemoteBuildBranches(remote = "origin") {
+    try {
+      const { stdout } = await execa2(
+        "git",
+        // Prefix form (trailing `/`): a `build/*` glob stops at the next `/`
+        // and would miss every build/<kind>/<details> branch.
+        ["for-each-ref", "--format=%(refname:short)", `refs/remotes/${remote}/build/`],
+        { cwd: this.cwd, stdio: "pipe" }
+      );
+      return stdout.trim().split("\n").filter(Boolean).map((ref) => ref.replace(`${remote}/`, ""));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Check if a remote branch is merged into the default branch
+   */
+  async isRemoteBranchMerged(remote, branch, defaultBranch) {
+    try {
+      await execa2(
+        "git",
+        ["merge-base", "--is-ancestor", `${remote}/${branch}`, `${remote}/${defaultBranch}`],
+        { cwd: this.cwd, stdio: "pipe" }
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get count of commits on remote branch ahead of default
+   */
+  async getRemoteAheadCount(remote, branch, defaultBranch) {
+    try {
+      const { stdout } = await execa2(
+        "git",
+        ["rev-list", "--count", `${remote}/${defaultBranch}..${remote}/${branch}`],
+        { cwd: this.cwd, stdio: "pipe" }
+      );
+      return parseInt(stdout.trim(), 10) || 0;
+    } catch {
+      return 0;
+    }
+  }
+  /**
+   * Get the currently analyzed local remote-tracking tip for a remote branch.
+   */
+  async getRemoteBranchTip(remote, branch) {
+    try {
+      const { stdout } = await execa2(
+        "git",
+        ["rev-parse", "--verify", `refs/remotes/${remote}/${branch}`],
+        { cwd: this.cwd, stdio: "pipe" }
+      );
+      const sha = stdout.trim();
+      return sha || null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Check if branch is the head of any open PR
+   * Returns the PR number if found, null otherwise
+   * SAFETY: Protects branches that are still referenced by open PRs
+   */
+  async getOpenPRForBranch(branch) {
+    try {
+      const result = await execa2(
+        "gh",
+        ["pr", "list", "--head", branch, "--state", "open", "--json", "number", "--limit", "1"],
+        { cwd: this.cwd, stdio: "pipe" }
+      );
+      const stdout = result.stdout || "";
+      const prs = JSON.parse(stdout.trim() || "[]");
+      return prs.length > 0 && prs[0] ? prs[0].number : null;
+    } catch {
+      return "unknown";
+    }
+  }
+  /**
+   * Analyze remote branches for cleanup
+   * SAFETY: Only analyzes build/* branches on the specified remote
+   */
+  async analyzeRemote(options = {}) {
+    const opts = {
+      remote: options.remote ?? "origin",
+      dryRun: options.dryRun ?? true,
+      requireMerged: options.requireMerged ?? true,
+      protectOpenPRs: options.protectOpenPRs ?? true,
+      confirm: options.confirm,
+      maxDeleteCount: options.maxDeleteCount ?? 50,
+      verbose: options.verbose ?? false
+    };
+    try {
+      await execa2("git", ["fetch", opts.remote, "--prune"], { cwd: this.cwd, stdio: "pipe" });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        mode: "dry-run",
+        remote: opts.remote,
+        defaultBranch: await this.getDefaultBranch(),
+        scanned: 0,
+        deleted: 0,
+        skipped: 0,
+        branches: [],
+        errors: [`Failed to fetch from ${opts.remote}: ${msg}`],
+        circuitBreakerTriggered: false
+      };
+    }
+    const result = {
+      mode: "dry-run",
+      remote: opts.remote,
+      defaultBranch: await this.getDefaultBranchForRemote(opts.remote),
+      scanned: 0,
+      deleted: 0,
+      skipped: 0,
+      branches: [],
+      errors: [],
+      circuitBreakerTriggered: false,
+      remoteRefsFetchedAndPruned: true
+    };
+    const remoteBranches = await this.getRemoteBuildBranches(opts.remote);
+    result.scanned = remoteBranches.length;
+    for (const branch of remoteBranches) {
+      if (result.deleted >= opts.maxDeleteCount) {
+        result.circuitBreakerTriggered = true;
+        result.branches.push({
+          name: branch,
+          fullRef: `${opts.remote}/${branch}`,
+          action: "skip",
+          reason: "circuit breaker triggered"
+        });
+        result.skipped++;
+        continue;
+      }
+      const analysis = await this.analyzeRemoteBranch(
+        opts.remote,
+        branch,
+        result.defaultBranch,
+        opts
+      );
+      result.branches.push(analysis);
+      if (analysis.action === "delete") {
+        result.deleted++;
+      } else {
+        result.skipped++;
+      }
+    }
+    return result;
+  }
+  /**
+   * Analyze a single remote branch
+   */
+  async analyzeRemoteBranch(remote, branch, defaultBranch, opts) {
+    const fullRef = `${remote}/${branch}`;
+    const kind = findBuildBranchShape(branch)?.kind;
+    if (kind === "removed") {
+      return {
+        name: branch,
+        fullRef,
+        action: "skip",
+        reason: "removed branch (use prune-removed)"
+      };
+    }
+    if (kind === "preflight") {
+      return {
+        name: branch,
+        fullRef,
+        action: "skip",
+        reason: "preflight branch"
+      };
+    }
+    if (!isEphemeralBuildBranchDeletionCandidate(branch)) {
+      const reason = kind === "sprint" || kind === "workflow" ? "run branch (not ephemeral)" : "not a recognized ephemeral build branch";
+      return {
+        name: branch,
+        fullRef,
+        action: "skip",
+        reason
+      };
+    }
+    const isMerged = await this.isRemoteBranchMerged(remote, branch, defaultBranch);
+    const aheadCount = await this.getRemoteAheadCount(remote, branch, defaultBranch);
+    if (opts.requireMerged && !isMerged) {
+      return {
+        name: branch,
+        fullRef,
+        action: "skip",
+        reason: `not merged (${aheadCount} commits ahead)`,
+        details: { isMerged, aheadCount }
+      };
+    }
+    if (opts.protectOpenPRs) {
+      const openPRNumber = await this.getOpenPRForBranch(branch);
+      if (openPRNumber === "unknown") {
+        return {
+          name: branch,
+          fullRef,
+          action: "skip",
+          reason: "open PR status unknown",
+          details: { isMerged, aheadCount }
+        };
+      }
+      if (openPRNumber !== null) {
+        return {
+          name: branch,
+          fullRef,
+          action: "skip",
+          reason: `open PR #${openPRNumber}`,
+          details: { isMerged, aheadCount, openPRNumber }
+        };
+      }
+    }
+    const expectedRemoteSha = await this.getRemoteBranchTip(remote, branch);
+    if (!expectedRemoteSha) {
+      return {
+        name: branch,
+        fullRef,
+        action: "skip",
+        reason: "remote tip unknown",
+        details: { isMerged, aheadCount }
+      };
+    }
+    return {
+      name: branch,
+      fullRef,
+      action: "delete",
+      reason: isMerged ? "merged into default" : "force delete (unmerged)",
+      details: { isMerged, aheadCount, expectedRemoteSha }
+    };
+  }
+  /**
+   * Delete remote branches
+   * SAFETY: Only deletes build/* branches that pass all checks
+   */
+  async deleteRemote(options = {}) {
+    const opts = {
+      remote: options.remote ?? "origin",
+      dryRun: options.dryRun ?? true,
+      requireMerged: options.requireMerged ?? true,
+      protectOpenPRs: options.protectOpenPRs ?? true,
+      confirm: options.confirm,
+      maxDeleteCount: options.maxDeleteCount ?? 50,
+      verbose: options.verbose ?? false
+    };
+    const analysis = await this.analyzeRemote(opts);
+    if (opts.dryRun) {
+      return analysis;
+    }
+    const deleteCount = analysis.branches.filter((b) => b.action === "delete").length;
+    if (opts.confirm !== deleteCount) {
+      analysis.errors.push(
+        `Confirmation mismatch: --confirm ${opts.confirm ?? "not provided"} but ${deleteCount} branches to delete. Use --confirm ${deleteCount} to proceed.`
+      );
+      return analysis;
+    }
+    analysis.mode = "executed";
+    for (const branch of analysis.branches) {
+      if (branch.action !== "delete") continue;
+      try {
+        const expectedRemoteSha = branch.details?.expectedRemoteSha;
+        if (!expectedRemoteSha) {
+          throw new Error("missing expected remote tip");
+        }
+        await execa2(
+          "git",
+          [
+            "push",
+            opts.remote,
+            `--force-with-lease=refs/heads/${branch.name}:${expectedRemoteSha}`,
+            `:refs/heads/${branch.name}`
+          ],
+          {
+            cwd: this.cwd,
+            stdio: "pipe"
+          }
+        );
+        branch.reason = `deleted from ${opts.remote}`;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        analysis.errors.push(`Failed to delete ${branch.fullRef}: ${msg}`);
+        branch.action = "skip";
+        branch.reason = `delete failed: ${msg}`;
+      }
+    }
+    analysis.deleted = analysis.branches.filter((b) => b.action === "delete").length;
+    analysis.skipped = analysis.branches.filter((b) => b.action === "skip").length;
+    return analysis;
+  }
+};
+function createBranchCleanupManager(cwd = process.cwd()) {
+  return new BranchCleanupManager(cwd);
+}
+
+export {
+  CLEANUP_UNBORN_REPOSITORY_INFO,
+  CLEANUP_HEAD_INSPECTION_ERROR,
+  resolveCleanupBuildDir,
+  cleanupCompetitionStateFiles,
+  DEFAULT_BRANCH_CLEANUP_AGE_DAYS,
+  BranchCleanupManager,
+  createBranchCleanupManager
+};
+//# sourceMappingURL=chunk-ZVVD2XGV.js.map