@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-UPHU64NB.js

@@ -0,0 +1,1327 @@
+import {
+  formatBytes
+} from "./chunk-JLS65NUQ.js";
+import {
+  isAncestor,
+  isStorageLockBusyError,
+  resolveRevision,
+  trackingRef,
+  withStorageLock
+} from "./chunk-BAWJNMWF.js";
+import {
+  contentAlreadyInDefault,
+  isSessionOwnedPath,
+  listSessionWorktrees,
+  sessionActivityMs
+} from "./chunk-LX4F24ZH.js";
+import {
+  resolvePlanningContextForRoot
+} from "./chunk-BBPIILO2.js";
+import {
+  CLEANUP_LOCK_FILENAME,
+  describeCleanupLockState,
+  formatCleanupLockContentionMessage,
+  isActiveRun,
+  isCleanupLockContentionError,
+  peekActiveRun,
+  tryWithCleanupLock,
+  withCleanupLock
+} from "./chunk-2NMNFUQA.js";
+import {
+  enqueueBranchCleanup,
+  getBranchCleanupQueuePath
+} from "./chunk-MULMXX4V.js";
+import {
+  parseGitWorktreePorcelain
+} from "./chunk-UTDEOPKV.js";
+import {
+  isProtectedPipelineBranch,
+  resolveDefaultBranch
+} from "./chunk-XGU6PBO5.js";
+import {
+  canonicalizePath,
+  safeRmDir
+} from "./chunk-ALDTFNZ3.js";
+import {
+  LabPathResolver
+} from "./chunk-C3KCMAJP.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import {
+  findProjectRoot
+} from "./chunk-35J4NE6S.js";
+import {
+  isQuietOutputRequested
+} from "./chunk-XWIZ6B5S.js";
+import {
+  listPreviousWorktreePools,
+  resolveSessionBase,
+  resolveWorktreeBase
+} from "./chunk-56WPYDJH.js";
+import {
+  BUILD_DEBUG,
+  BUILD_WORKTREE_TTL_DAYS,
+  emitWarning,
+  readEnv,
+  readRawEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/cleanup/session-cleanup.ts
+import { promises as fs } from "fs";
+import path from "path";
+var ACTIVE_WINDOW_MS = 30 * 60 * 1e3;
+var READ_ONLY_GIT_ENV = { GIT_OPTIONAL_LOCKS: "0" };
+async function runGit(cwd, args) {
+  try {
+    const result = await execGit(args, { cwd, timeoutMs: 2e4, env: READ_ONLY_GIT_ENV });
+    return { ok: result.exitCode === 0, stdout: result.stdout };
+  } catch {
+    return { ok: false, stdout: "" };
+  }
+}
+async function canonical(p) {
+  return fs.realpath(p).catch(() => path.resolve(p));
+}
+function isWithin(child, parent) {
+  const rel = path.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+async function listRegistered(repoRoot) {
+  const result = await execGit(["worktree", "list", "--porcelain"], { cwd: repoRoot });
+  if (result.exitCode !== 0) {
+    throw new Error(`git worktree list exited ${result.exitCode}: ${result.stderr.trim()}`);
+  }
+  const entries = [];
+  for (const line of result.stdout.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      entries.push({ path: await canonical(line.slice("worktree ".length)), locked: false });
+    } else if (line === "locked" || line.startsWith("locked ")) {
+      const last = entries[entries.length - 1];
+      if (last) last.locked = true;
+    }
+  }
+  return entries;
+}
+async function statusEntries(cwd, ignored, pathspecs = []) {
+  const result = await runGit(cwd, [
+    "status",
+    "--porcelain=v1",
+    "-z",
+    "--untracked-files=all",
+    `--ignored=${ignored}`,
+    ...pathspecs.length > 0 ? ["--", ...pathspecs] : []
+  ]);
+  if (!result.ok) return void 0;
+  return result.stdout.split("\0").filter(Boolean).map((entry) => [entry.slice(0, 2), entry.slice(3)]);
+}
+var REGENERABLE_BUILD_OUTPUTS = ["dist", "coverage", ".tsbuildinfo"];
+var WORKING_DOC_DIRS = [".build-project/planning", ".build-project/security"];
+async function ignoredWorkingDocs(cwd) {
+  const docs = await statusEntries(cwd, "traditional", WORKING_DOC_DIRS);
+  return docs?.filter(([code]) => code === "!!").map(([, file]) => file);
+}
+async function regenerableIgnored(lane) {
+  const recorded = (await fs.readFile(path.join(lane, ".build-project", "session", "ignored-untracked"), "utf8").catch(() => "")).split("\n").map((line) => line.trim().replace(/\/+$/, "")).filter(Boolean);
+  const fixed = ["node_modules", ...REGENERABLE_BUILD_OUTPUTS, ...recorded];
+  return (file) => {
+    const bare = file.replace(/\/+$/, "");
+    if (bare === ".build-project" || bare.startsWith(".build-project/")) return true;
+    if (!bare.includes("/") && bare.endsWith(".tsbuildinfo")) return true;
+    return fixed.some((entry) => bare === entry || bare.startsWith(`${entry}/`));
+  };
+}
+async function branchStartCommit(lane, branch) {
+  const result = await runGit(lane, ["reflog", "show", "--format=%H", `refs/heads/${branch}`]);
+  if (!result.ok) return void 0;
+  const oldest = result.stdout.split("\n").filter(Boolean).pop()?.trim();
+  return oldest && /^[0-9a-f]{40,64}$/.test(oldest) ? oldest : void 0;
+}
+async function inspectStorageChild(childPath, ctx, reasons) {
+  if (await peekActiveRun(childPath).catch(() => true)) {
+    reasons.push("planning worktree has an active run");
+  }
+  const status = await statusEntries(childPath, "matching");
+  if (!status) {
+    reasons.push("planning worktree could not be inspected");
+    return void 0;
+  }
+  if (status.length > 0) {
+    reasons.push("planning worktree has uncommitted or ignored files");
+  }
+  const head = await resolveRevision(childPath, "HEAD");
+  const tip = await resolveRevision(childPath, trackingRef(ctx));
+  if (!head || !tip) {
+    reasons.push("planning worktree remote ref is unavailable");
+  } else if (!await isAncestor(childPath, head, tip)) {
+    reasons.push("planning worktree has unpublished commits");
+  }
+  return head;
+}
+async function inspectLane(repoRoot, session, registered, defaultBranch, options) {
+  const reasons = [...session.problems];
+  const snapshot = {};
+  const lane = session.path;
+  const callers = [await canonical(options.callerCwd), await canonical(repoRoot)];
+  if (callers.some((caller) => isWithin(caller, lane))) {
+    reasons.push("current directory is inside this session");
+  }
+  if (!session.branch) {
+    reasons.push("no branch checked out");
+  } else if (isProtectedPipelineBranch(session.branch, void 0, repoRoot)) {
+    reasons.push("protected branch");
+  }
+  if (session.locked) reasons.push("locked by git");
+  const nested = registered.filter((entry) => entry.path !== lane && isWithin(entry.path, lane));
+  let childPath;
+  let ctx;
+  try {
+    ctx = resolvePlanningContextForRoot(lane);
+    if (ctx.backend === "git-branch") childPath = await canonical(ctx.storageRoot);
+  } catch {
+    reasons.push("planning storage configuration could not be read");
+  }
+  const childRegistered = childPath ? nested.find((entry) => entry.path === childPath) : void 0;
+  for (const entry of nested) {
+    if (entry !== childRegistered) {
+      reasons.push(`nested worktree ${path.relative(lane, entry.path)}`);
+    }
+  }
+  const childExists = childPath ? await fs.stat(childPath).then(
+    () => true,
+    () => false
+  ) : false;
+  if (childPath && childExists && !childRegistered) {
+    reasons.push("planning storage directory is not a registered worktree");
+  }
+  for (const target of [lane, ...nested.map((entry) => entry.path)]) {
+    if (await peekActiveRun(target).catch(() => true)) {
+      reasons.push("active run");
+      break;
+    }
+  }
+  const head = await resolveRevision(lane, "HEAD");
+  snapshot.head = head;
+  const commitSeconds = Number((await runGit(lane, ["log", "-1", "--format=%ct"])).stdout.trim());
+  const lastActive = Math.max(
+    Number.isFinite(commitSeconds) ? commitSeconds * 1e3 : 0,
+    await sessionActivityMs(lane)
+  );
+  if (!head) reasons.push("HEAD could not be resolved");
+  else if (options.now - lastActive < ACTIVE_WINDOW_MS)
+    reasons.push("active in the last 30 minutes");
+  const status = await statusEntries(lane, "matching");
+  if (!status) {
+    reasons.push("status could not be inspected");
+  } else {
+    const childRel = childPath ? `${path.relative(lane, childPath).split(path.sep).join("/")}/` : void 0;
+    const isRegenerable = await regenerableIgnored(lane);
+    const exempt = ([code, file]) => childRegistered !== void 0 && file === childRel && (code === "??" || code === "!!") || code === "!!" && isRegenerable(file);
+    const dirty = status.filter((entry) => !exempt(entry));
+    if (dirty.some(([code]) => code !== "??" && code !== "!!")) reasons.push("uncommitted changes");
+    if (dirty.some(([code]) => code === "??")) reasons.push("untracked files");
+    const docs = await ignoredWorkingDocs(lane);
+    const ignoredPaths = [
+      ...dirty.filter(([code]) => code === "!!").map(([, file]) => file),
+      ...docs ?? []
+    ];
+    if (!docs) reasons.push("status could not be inspected");
+    if (ignoredPaths.length > 0) {
+      const shown = ignoredPaths.slice(0, 3).join(", ");
+      const more = ignoredPaths.length > 3 ? ` (+${ignoredPaths.length - 3} more)` : "";
+      reasons.push(`ignored files: ${shown}${more}`);
+    }
+  }
+  if (head && session.branch) {
+    const start = await branchStartCommit(lane, session.branch);
+    if (!start) reasons.push("session start commit could not be determined");
+    else if (start === head) reasons.push("no commits since the session started");
+  }
+  const defaultRef = `refs/remotes/origin/${defaultBranch}`;
+  const defaultSha = await resolveRevision(lane, defaultRef);
+  snapshot.defaultSha = defaultSha;
+  if (!defaultSha) {
+    reasons.push(`origin/${defaultBranch} is not available`);
+  } else if (!await contentAlreadyInDefault(lane, defaultRef)) {
+    reasons.push(`not in origin/${defaultBranch}`);
+  }
+  if (childPath && childRegistered && ctx) {
+    if (childRegistered.locked) reasons.push("planning worktree is locked");
+    snapshot.childPath = childPath;
+    snapshot.childHead = await inspectStorageChild(childPath, ctx, reasons);
+  }
+  const kept = reasons.length > 0;
+  return {
+    entry: {
+      path: lane,
+      branch: session.branch,
+      state: kept ? "kept" : "eligible",
+      reasons: [...new Set(reasons)]
+    },
+    snapshot
+  };
+}
+async function inspectAll(repoRoot, options) {
+  const resolved = {
+    now: options.now ?? Date.now(),
+    callerCwd: options.callerCwd ?? process.cwd()
+  };
+  const report = { sessions: [], eligible: [], kept: [], errors: [] };
+  const snapshots = /* @__PURE__ */ new Map();
+  let sessions;
+  let registered;
+  try {
+    sessions = await listSessionWorktrees(repoRoot);
+    registered = await listRegistered(repoRoot);
+  } catch (error) {
+    report.errors.push(error instanceof Error ? error.message : String(error));
+    return { report, snapshots };
+  }
+  const defaultBranch = await resolveDefaultBranch(repoRoot);
+  for (const session of sessions) {
+    try {
+      const { entry, snapshot } = await inspectLane(
+        repoRoot,
+        session,
+        registered,
+        defaultBranch,
+        resolved
+      );
+      report.sessions.push(entry);
+      (entry.state === "eligible" ? report.eligible : report.kept).push(entry);
+      snapshots.set(entry.path, snapshot);
+    } catch (error) {
+      const entry = {
+        path: session.path,
+        branch: session.branch,
+        state: "kept",
+        reasons: ["could not be inspected"]
+      };
+      report.sessions.push(entry);
+      report.kept.push(entry);
+      report.errors.push(
+        `${session.path}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return { report, snapshots };
+}
+async function inspectOne(repoRoot, lanePath, options) {
+  const session = (await listSessionWorktrees(repoRoot)).find((s) => s.path === lanePath);
+  if (!session) return void 0;
+  return inspectLane(
+    repoRoot,
+    session,
+    await listRegistered(repoRoot),
+    await resolveDefaultBranch(repoRoot),
+    {
+      now: options.now ?? Date.now(),
+      callerCwd: options.callerCwd ?? process.cwd()
+    }
+  );
+}
+async function inspectSessionCleanup(repoRoot, options = {}) {
+  return (await inspectAll(repoRoot, options)).report;
+}
+async function removeWorktree(repoRoot, target) {
+  const result = await execGit(["worktree", "remove", target], { cwd: repoRoot }).catch(
+    (error) => error
+  );
+  if (result instanceof Error) return result.message;
+  return result.exitCode === 0 ? void 0 : result.stderr.trim() || `exit ${result.exitCode}`;
+}
+async function removeLane(repoRoot, lanePath, before, options, result) {
+  const recheckAndRemove = async () => {
+    const { entry, snapshot: after } = await inspectOne(repoRoot, lanePath, options) ?? {};
+    const unchanged = after !== void 0 && after.head === before.head && after.defaultSha === before.defaultSha && after.childPath === before.childPath && after.childHead === before.childHead;
+    if (!entry || entry.state !== "eligible" || !unchanged) {
+      markKept(
+        result,
+        lanePath,
+        entry?.reasons.length ? entry.reasons : ["changed during cleanup"]
+      );
+      return;
+    }
+    if (before.childPath) {
+      const childError = await removeWorktree(repoRoot, before.childPath);
+      if (childError) {
+        markKept(result, lanePath, ["planning worktree could not be removed"]);
+        result.errors.push(`${before.childPath}: ${childError}`);
+        return;
+      }
+    }
+    const laneError = await removeWorktree(repoRoot, lanePath);
+    if (laneError) {
+      markKept(result, lanePath, ["could not be removed"]);
+      result.errors.push(`${lanePath}: ${laneError}`);
+      return;
+    }
+    result.removed.push(lanePath);
+  };
+  if (!before.childPath) return recheckAndRemove();
+  try {
+    await withStorageLock(before.childPath, recheckAndRemove, { wait: false });
+  } catch (error) {
+    if (!isStorageLockBusyError(error)) {
+      markKept(result, lanePath, ["planning storage could not be locked"]);
+      result.errors.push(`${lanePath}: ${error instanceof Error ? error.message : String(error)}`);
+      return;
+    }
+    markKept(result, lanePath, ["planning storage is busy"]);
+  }
+}
+function markKept(result, lanePath, reasons) {
+  const entry = result.sessions.find((candidate) => candidate.path === lanePath);
+  if (!entry) return;
+  entry.state = "kept";
+  entry.reasons = reasons;
+}
+async function cleanupSessions(repoRoot, options) {
+  const { report, snapshots } = await inspectAll(repoRoot, options);
+  const result = { ...report, removed: [] };
+  if (!options.execute || report.eligible.length === 0) return result;
+  const planned = report.eligible.map((entry) => entry.path);
+  let lockErrored = false;
+  const ran = await tryWithCleanupLock(resolveSessionBase(repoRoot), async () => {
+    for (const lanePath of planned) {
+      try {
+        await removeLane(repoRoot, lanePath, snapshots.get(lanePath) ?? {}, options, result);
+      } catch (error) {
+        markKept(result, lanePath, ["could not be removed"]);
+        result.errors.push(
+          `${lanePath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    return true;
+  }).catch((error) => {
+    result.errors.push(error instanceof Error ? error.message : String(error));
+    lockErrored = true;
+    return null;
+  });
+  if (ran === null && !lockErrored) {
+    result.errors.push("session cleanup lock is held by another process");
+  }
+  result.eligible = result.sessions.filter((entry) => entry.state === "eligible");
+  result.kept = result.sessions.filter((entry) => entry.state === "kept");
+  return result;
+}
+async function cleanupSessionsCategory(repoRoot, options) {
+  const result = await cleanupSessions(repoRoot, { execute: !options.dryRun, now: options.now });
+  if (result.sessions.length === 0 && result.errors.length > 0) {
+    return {
+      name: "sessions",
+      enabled: true,
+      skipped: { reason: result.errors[0] ?? "session inspection failed" },
+      summary: { found: 0, cleaned: 0, freedBytes: 0 },
+      details: result
+    };
+  }
+  return {
+    name: "sessions",
+    enabled: true,
+    summary: {
+      found: result.sessions.length,
+      cleaned: options.dryRun ? result.eligible.length : result.removed.length,
+      freedBytes: 0
+    },
+    details: result
+  };
+}
+
+// src/utils/worktree-cleanup.ts
+import { execFileSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { readdir, stat } from "fs/promises";
+import { basename, isAbsolute, join, relative, resolve, sep } from "path";
+import { execa } from "execa";
+var DEFAULT_WORKTREE_TTL_DAYS = 1;
+var MIN_WORKTREE_CLEANUP_AGE_MS = 60 * 60 * 1e3;
+var LABS_RELATIVE_PATH = ".build-project/labs";
+function isCleanupLockArtifactName(name) {
+  return name === CLEANUP_LOCK_FILENAME || name === `${CLEANUP_LOCK_FILENAME}.lock`;
+}
+function logCleanupMessage(message) {
+  if (isQuietOutputRequested()) {
+    return;
+  }
+  console.log(message);
+}
+var worktreeCleanupMutexTail = Promise.resolve();
+function runWorktreeCleanupSerialized(fn) {
+  const run = worktreeCleanupMutexTail.then(fn);
+  worktreeCleanupMutexTail = run.then(
+    () => void 0,
+    () => void 0
+  );
+  return run;
+}
+function pathDepth(pathValue) {
+  return pathValue.split(sep).filter(Boolean).length;
+}
+function isNestedPath(parentPath, maybeChildPath) {
+  const parent = canonicalizePath(parentPath);
+  const child = canonicalizePath(maybeChildPath);
+  return child !== parent && child.startsWith(`${parent}${sep}`);
+}
+function isPathWithinDir(candidatePath, dirPath) {
+  const rel = relative(canonicalizePath(dirPath), canonicalizePath(candidatePath));
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function isCanonicalLabWorktreePath(candidatePath) {
+  const segments = resolve(candidatePath).split(sep);
+  const tail = segments.slice(-7);
+  return tail.length === 7 && tail[0] === ".build-project" && tail[1] === "labs" && tail[3] === "runs" && tail[5] === "worktrees";
+}
+function getMaxWorktreeAge() {
+  const raw = readRawEnv(BUILD_WORKTREE_TTL_DAYS);
+  if (raw === void 0) {
+    return DEFAULT_WORKTREE_TTL_DAYS * 24 * 60 * 60 * 1e3;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    emitWarning(
+      "CFG-002",
+      {
+        subsystem: "utils",
+        executionPhase: "setup"
+      },
+      {
+        severity: "WARN" /* WARN */,
+        metadata: {
+          configKey: "BUILD_WORKTREE_TTL_DAYS",
+          invalidValue: raw,
+          fallbackValue: DEFAULT_WORKTREE_TTL_DAYS
+        }
+      }
+    );
+    return DEFAULT_WORKTREE_TTL_DAYS * 24 * 60 * 60 * 1e3;
+  }
+  return parsed * 24 * 60 * 60 * 1e3;
+}
+var WorktreeCleanupManager = class {
+  baseDir;
+  constructor(baseDir) {
+    this.baseDir = baseDir;
+  }
+  /**
+   * Get worktree base directory
+   *
+   * @returns Absolute path to worktree base directory
+   */
+  getWorktreeBase() {
+    if (this.baseDir) {
+      return this.baseDir;
+    }
+    return resolveWorktreeBase();
+  }
+  /**
+   * Read directories under the given path and add them to the candidate map
+   */
+  async populateCandidatesFromDir(dirPath, source, map, labPaths) {
+    if (!existsSync(dirPath)) return;
+    try {
+      const entries = await readdir(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (isCleanupLockArtifactName(entry.name)) continue;
+        if (!entry.isDirectory()) continue;
+        const entryPath = resolve(dirPath, entry.name);
+        if (map.has(entryPath)) continue;
+        map.set(entryPath, {
+          path: entryPath,
+          name: entry.name,
+          source,
+          registeredGitWorktree: false
+        });
+        if (source === "lab") {
+          labPaths.add(entryPath);
+        }
+      }
+    } catch (error) {
+      this.logDebug(`Failed to read worktree directory ${dirPath}`, error);
+    }
+  }
+  /**
+   * Discover lab worktrees under .build-project/labs
+   */
+  async discoverLabWorktrees(repoRoot, map, labPaths) {
+    const labsRoot = resolve(repoRoot, LABS_RELATIVE_PATH);
+    if (!existsSync(labsRoot)) return;
+    try {
+      const labs = await readdir(labsRoot, { withFileTypes: true });
+      for (const labEntry of labs) {
+        if (!labEntry.isDirectory()) continue;
+        const runsPath = join(labsRoot, labEntry.name, "runs");
+        if (!existsSync(runsPath)) continue;
+        const runs = await readdir(runsPath, { withFileTypes: true });
+        for (const runEntry of runs) {
+          if (!runEntry.isDirectory()) continue;
+          const worktreesPath = join(runsPath, runEntry.name, "worktrees");
+          await this.populateCandidatesFromDir(worktreesPath, "lab", map, labPaths);
+        }
+      }
+    } catch (error) {
+      this.logDebug("Failed to discover lab worktrees", error);
+    }
+  }
+  /**
+   * Discover worktrees created by older Build versions under the target repo.
+   * New default worktree pools live outside the checkout, but cleanup must still
+   * drain this legacy location so old crash debris does not keep tainting host
+   * verification or test discovery.
+   */
+  async discoverLegacyRepoLocalWorktrees(repoRoot, map, labPaths) {
+    if (this.baseDir) return;
+    const legacyWorktreeBase = resolve(repoRoot, ".build-project/tmp/worktrees");
+    if (resolve(this.getWorktreeBase()) !== legacyWorktreeBase) {
+      await this.populateCandidatesFromDir(legacyWorktreeBase, "standard", map, labPaths);
+    }
+    for (const previousPool of this.getPreviousWorktreePools(repoRoot)) {
+      await this.populateCandidatesFromDir(previousPool, "standard", map, labPaths);
+    }
+  }
+  getPreviousWorktreePools(repoRoot) {
+    if (this.baseDir) return [];
+    try {
+      return listPreviousWorktreePools(repoRoot);
+    } catch (error) {
+      this.logDebug("Failed to resolve previous worktree pools", error);
+      return [];
+    }
+  }
+  /**
+   * Discover stale worktree-shaped directories that escaped the standard
+   * .build-project/tmp/worktrees bucket. These are limited to directories with a .git
+   * file whose gitdir target no longer exists, so regular tmp directories are
+   * not promoted into worktree cleanup candidates.
+   */
+  async discoverBrokenMetadataTmpWorktrees(repoRoot, map) {
+    if (this.baseDir) return;
+    const tmpRoot = resolve(repoRoot, ".build-project/tmp");
+    if (!existsSync(tmpRoot)) return;
+    const visit = async (dirPath, depth) => {
+      if (depth > 3) return;
+      if (existsSync(join(dirPath, ".git")) && this.hasBrokenGitdirPointer(dirPath)) {
+        if (!map.has(dirPath)) {
+          map.set(dirPath, {
+            path: dirPath,
+            name: basename(dirPath),
+            source: "standard",
+            registeredGitWorktree: false
+          });
+        }
+        return;
+      }
+      let entries;
+      try {
+        entries = await readdir(dirPath, { withFileTypes: true });
+      } catch (error) {
+        this.logDebug(`Failed to scan tmp directory ${dirPath}`, error);
+        return;
+      }
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        await visit(join(dirPath, entry.name), depth + 1);
+      }
+    };
+    await visit(tmpRoot, 0);
+  }
+  /**
+   * True when a git-discovered worktree lives under a Build-managed cleanup root.
+   * External manual worktrees registered in Git but outside these roots are preserved.
+   */
+  isUnderBuildManagedCleanupRoot(candidatePath, repoRoot, worktreeBase) {
+    const resolved = resolve(candidatePath);
+    if (isPathWithinDir(resolved, resolve(worktreeBase))) {
+      return true;
+    }
+    if (this.getPreviousWorktreePools(repoRoot).some((pool) => isPathWithinDir(resolved, pool))) {
+      return true;
+    }
+    if (isPathWithinDir(resolved, resolve(repoRoot, LABS_RELATIVE_PATH)) || isCanonicalLabWorktreePath(resolved)) {
+      return true;
+    }
+    return isPathWithinDir(resolved, resolve(repoRoot, ".build-project/tmp"));
+  }
+  /**
+   * Parse git worktree metadata for both branch-backed and detached worktrees.
+   */
+  async discoverGitWorktreeEntries(repoRoot) {
+    const entries = [];
+    try {
+      const { stdout } = await execa("git", ["worktree", "list", "--porcelain"], {
+        cwd: repoRoot,
+        stdio: "pipe"
+      });
+      for (const record of parseGitWorktreePorcelain(stdout)) {
+        const entry = {
+          path: resolve(repoRoot, record.path.trim()),
+          detached: false
+        };
+        for (const field of record.fields) {
+          if (field.name === "branch" && field.value !== void 0) {
+            entry.branchName = field.value.trim().replace(/^refs\/heads\//, "");
+          } else if (field.rawLine === "detached") {
+            entry.detached = true;
+          } else if (field.rawLine.trim() === "") {
+            break;
+          }
+        }
+        entries.push(entry);
+      }
+    } catch (error) {
+      this.logDebug("Failed to list git worktrees", error);
+    }
+    return entries;
+  }
+  /**
+   * Build a map of all known worktree candidates
+   */
+  async gatherWorktreeCandidates(includeBrokenMetadata) {
+    const repoRoot = findProjectRoot(process.cwd()) ?? process.cwd();
+    const candidateMap = /* @__PURE__ */ new Map();
+    const labPaths = /* @__PURE__ */ new Set();
+    await this.populateCandidatesFromDir(
+      this.getWorktreeBase(),
+      "standard",
+      candidateMap,
+      labPaths
+    );
+    await this.discoverLegacyRepoLocalWorktrees(repoRoot, candidateMap, labPaths);
+    await this.discoverLabWorktrees(repoRoot, candidateMap, labPaths);
+    if (includeBrokenMetadata) {
+      await this.discoverBrokenMetadataTmpWorktrees(repoRoot, candidateMap);
+    }
+    const inGitRepo = isInsideGitWorkTree(repoRoot);
+    const gitEntries = inGitRepo ? await this.discoverGitWorktreeEntries(repoRoot) : [];
+    const registeredWorktreePaths = new Set(
+      gitEntries.map((entry) => canonicalizePath(entry.path))
+    );
+    const candidateKeyByCanonical = /* @__PURE__ */ new Map();
+    for (const key of candidateMap.keys()) {
+      candidateKeyByCanonical.set(canonicalizePath(key), key);
+    }
+    for (const entry of gitEntries) {
+      entry.path = candidateKeyByCanonical.get(canonicalizePath(entry.path)) ?? entry.path;
+      const existing = candidateMap.get(entry.path);
+      if (existing) {
+        existing.branchName ??= entry.branchName;
+        existing.detached = entry.detached;
+        existing.registeredGitWorktree = true;
+        existing.missingOnDisk = !existsSync(entry.path);
+        if (isCanonicalLabWorktreePath(entry.path)) {
+          existing.source = "lab";
+          labPaths.add(entry.path);
+        }
+        continue;
+      }
+      const source = labPaths.has(entry.path) || isCanonicalLabWorktreePath(entry.path) ? "lab" : "git";
+      candidateMap.set(entry.path, {
+        path: entry.path,
+        name: basename(entry.path),
+        branchName: entry.branchName,
+        detached: entry.detached,
+        missingOnDisk: !existsSync(entry.path),
+        source,
+        registeredGitWorktree: true
+      });
+      if (source === "lab") {
+        labPaths.add(entry.path);
+      }
+    }
+    const canonicalRoot = canonicalizePath(repoRoot);
+    for (const [path2, _candidate] of candidateMap) {
+      if (canonicalizePath(path2) === canonicalRoot || isSessionOwnedPath(path2)) {
+        candidateMap.delete(path2);
+      }
+    }
+    return {
+      repoRoot,
+      candidates: Array.from(candidateMap.values()),
+      registeredWorktreePaths
+    };
+  }
+  /**
+   * Get size of a directory recursively
+   *
+   * Applies conservative traversal limits to avoid runaway recursion on
+   * pathological directory structures or mocked filesystems in tests.
+   *
+   * @param dirPath Directory path
+   * @param maxDepth Maximum recursion depth to prevent stack overflow (default: 50)
+   * @param currentDepth Current recursion depth (internal use)
+   * @param traversal Tracker for total entries visited (internal use)
+   * @returns Size in bytes
+   * @private
+   */
+  async getDirSize(dirPath, maxDepth = 50, currentDepth = 0, traversal = { count: 0 }) {
+    let size = 0;
+    const MAX_TRAVERSAL_ENTRIES = 5e3;
+    if (currentDepth >= maxDepth) {
+      this.logDebug(
+        `Max depth ${maxDepth} reached for ${dirPath}`,
+        new Error("Max depth exceeded")
+      );
+      return size;
+    }
+    traversal.count++;
+    if (traversal.count > MAX_TRAVERSAL_ENTRIES) {
+      this.logDebug(
+        `Traversal limit ${MAX_TRAVERSAL_ENTRIES} reached for ${dirPath}`,
+        new Error("Traversal limit exceeded")
+      );
+      return size;
+    }
+    try {
+      const entries = await readdir(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const entryPath = join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+          size += await this.getDirSize(entryPath, maxDepth, currentDepth + 1, traversal);
+        } else if (entry.isFile()) {
+          const stats = await stat(entryPath);
+          size += stats.size;
+        }
+      }
+    } catch (error) {
+      this.logDebug(`Failed to calculate size for ${dirPath}`, error);
+    }
+    return size;
+  }
+  /**
+   * Format age in human-readable form
+   *
+   * @param ms Age in milliseconds
+   * @returns Formatted age string
+   * @private
+   */
+  formatAge(ms) {
+    const hours = Math.floor(ms / (60 * 60 * 1e3));
+    const days = Math.floor(hours / 24);
+    if (days > 0) {
+      return `${days}d ${hours % 24}h`;
+    }
+    return `${hours}h`;
+  }
+  hasBrokenGitdirPointer(worktreePath) {
+    const gitFilePath = join(worktreePath, ".git");
+    if (!existsSync(gitFilePath)) {
+      return false;
+    }
+    try {
+      const gitFile = readFileSync(gitFilePath, "utf8");
+      const match = gitFile.match(/^gitdir:\s*(.+)$/m);
+      if (!match) {
+        return false;
+      }
+      const gitdirTarget = match[1]?.trim();
+      if (!gitdirTarget) {
+        return false;
+      }
+      const gitdirPath = resolve(worktreePath, gitdirTarget);
+      return !existsSync(gitdirPath);
+    } catch {
+      return false;
+    }
+  }
+  async inspectWorktreeChangeState(worktreePath) {
+    if (this.hasBrokenGitdirPointer(worktreePath)) {
+      return "broken-gitdir";
+    }
+    try {
+      const result = await execa(
+        "git",
+        ["-C", worktreePath, "status", "--porcelain=v1", "--untracked-files=all"],
+        {
+          stdio: "pipe",
+          reject: false,
+          timeout: 1e4
+        }
+      );
+      if (result.exitCode === 0 && !result.timedOut && !result.isTerminated) {
+        if ((result?.stdout ?? "").trim().length > 0) return "dirty";
+        const docs = await ignoredWorkingDocs(worktreePath);
+        if (docs) return docs.length > 0 ? "dirty" : "clean";
+      }
+    } catch {
+    }
+    return existsSync(join(worktreePath, ".git")) ? "uninspectable" : "clean";
+  }
+  async resolveBranchHeadSha(repoRoot, branchName) {
+    try {
+      const { stdout } = await execa(
+        "git",
+        ["rev-parse", "--verify", `refs/heads/${branchName}^{commit}`],
+        {
+          cwd: repoRoot,
+          stdio: "pipe"
+        }
+      );
+      return stdout.trim() || void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  async resolveCurrentBranchName(repoRoot) {
+    try {
+      const { stdout } = await execa("git", ["branch", "--show-current"], {
+        cwd: repoRoot,
+        stdio: "pipe"
+      });
+      return stdout.trim() || void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  shouldFailClosedForMissingGitMetadata(candidate) {
+    return !this.baseDir && candidate.source === "standard" && !candidate.registeredGitWorktree && !existsSync(join(candidate.path, ".git"));
+  }
+  canCleanBrokenMetadataCandidate(candidate) {
+    return candidate.source === "standard" && !candidate.registeredGitWorktree;
+  }
+  /** Remove only an approved, absent worktree; Git still refuses locked registrations. */
+  async deregisterMissingWorktree(worktreePath, repoRoot) {
+    if (existsSync(worktreePath)) return false;
+    try {
+      const removed = await execGit(["worktree", "remove", "--force", "--", worktreePath], {
+        cwd: repoRoot
+      });
+      return removed.exitCode === 0;
+    } catch (error) {
+      this.logDebug(`Could not deregister missing worktree ${worktreePath}`, error);
+      return false;
+    }
+  }
+  /**
+   * Clean up old worktrees
+   *
+   * Deletes worktrees older than TTL (default 1 day) to prevent disk bloat.
+   * Worktrees are temporary build artifacts and should not accumulate.
+   *
+   * @param options Optional cleanup options (dry-run, age override)
+   * @returns Cleanup report with statistics
+   */
+  async cleanup(options) {
+    const dryRun = options?.dryRun ?? false;
+    const baseDir = this.getWorktreeBase();
+    return runWorktreeCleanupSerialized(async () => {
+      const body = () => this.cleanupSerializedBody(options);
+      if (dryRun) {
+        if (!existsSync(baseDir)) {
+          return await body();
+        }
+        const lockedResult = await tryWithCleanupLock(baseDir, body);
+        if (lockedResult !== null) {
+          return lockedResult;
+        }
+        const diagnostics = await describeCleanupLockState(baseDir);
+        const report = await body();
+        report.lockPreviewDegraded = true;
+        report.lockDiagnostics = diagnostics;
+        return report;
+      }
+      try {
+        return await withCleanupLock(baseDir, body);
+      } catch (error) {
+        if (isCleanupLockContentionError(error)) {
+          const diagnostics = await describeCleanupLockState(baseDir);
+          throw Object.assign(
+            new Error(formatCleanupLockContentionMessage(diagnostics, "execute")),
+            { code: "ELOCKED", file: diagnostics.lockPath }
+          );
+        }
+        throw error;
+      }
+    });
+  }
+  async cleanupSerializedBody(options) {
+    const maxAge = options?.maxAgeMs ?? getMaxWorktreeAge();
+    const dryRun = options?.dryRun ?? false;
+    const includeLabs = options?.includeLabs ?? false;
+    const verbose = options?.verbose ?? true;
+    const verbosePreserved = options?.verbosePreserved ?? false;
+    const limit = Math.max(0, Math.floor(options?.limit ?? 0));
+    const estimateSize = options?.estimateSize ?? true;
+    const includeBrokenMetadata = options?.includeBrokenMetadata ?? false;
+    if (maxAge === 0) {
+      emitWarning(
+        "CFG-006",
+        {
+          subsystem: "utils",
+          executionPhase: "cleanup"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            configKey: "maxAge",
+            invalidValue: 0,
+            message: "maxAge=0 matches age-eligible worktrees, but fresh worktrees are still protected by the minimum age gate."
+          }
+        }
+      );
+    }
+    const report = {
+      deleted: 0,
+      freedBytes: 0,
+      deletedWorktrees: [],
+      dryRun,
+      deletedLabWorktrees: [],
+      skippedLabWorktrees: [],
+      // Effective threshold: the configured max age floored at the fixed one-hour
+      // minimum, so a `--max-age 0` sweep explains its skips with the value that
+      // actually blocked them.
+      retentionMaxAgeMs: Math.max(maxAge, MIN_WORKTREE_CLEANUP_AGE_MS)
+    };
+    const recordPreserved = (candidate, reason) => {
+      report.preservedWorktrees ??= [];
+      if (report.preservedWorktrees.some(
+        (entry) => entry.path === candidate.path && entry.reason === reason
+      )) {
+        return;
+      }
+      report.preservedWorktrees.push({
+        name: candidate.name,
+        path: candidate.path,
+        source: candidate.source,
+        reason
+      });
+    };
+    try {
+      const { repoRoot, candidates, registeredWorktreePaths } = await this.gatherWorktreeCandidates(includeBrokenMetadata);
+      if (candidates.length === 0) {
+        return report;
+      }
+      const labResolver = LabPathResolver.getInstance();
+      const labModeActive = labResolver.isLabMode();
+      const skipLabCleanup = !includeLabs;
+      const labCandidates = candidates.filter((c) => c.source === "lab");
+      const actionableCandidatesAll = skipLabCleanup ? candidates.filter((c) => c.source !== "lab") : candidates;
+      const actionableCandidates = actionableCandidatesAll.map((candidate, index) => ({ candidate, index })).sort((a, b) => {
+        if (a.candidate.missingOnDisk !== b.candidate.missingOnDisk) {
+          return a.candidate.missingOnDisk ? -1 : 1;
+        }
+        const depthDelta = pathDepth(canonicalizePath(b.candidate.path)) - pathDepth(canonicalizePath(a.candidate.path));
+        if (depthDelta !== 0) {
+          return depthDelta;
+        }
+        return a.index - b.index;
+      }).map(({ candidate }) => candidate).slice(0, limit > 0 ? limit : void 0);
+      if (limit > 0 && actionableCandidatesAll.length > limit) {
+        logCleanupMessage(
+          `Worktree cleanup limited to first ${limit} of ${actionableCandidatesAll.length} eligible candidate(s). Re-run to continue.`
+        );
+      }
+      if (skipLabCleanup && labCandidates.length > 0) {
+        report.skippedLabWorktrees = labCandidates.map((c) => c.name);
+        for (const candidate of labCandidates) {
+          recordPreserved(candidate, "lab");
+        }
+        const message = labModeActive ? `Lab mode active - preserving ${labCandidates.length} lab worktree(s). Use '--include-labs' to override.` : `Skipped ${labCandidates.length} lab worktree(s). Use '--include-labs' to override.`;
+        if (verbose && verbosePreserved) {
+          logCleanupMessage(message);
+        }
+      }
+      for (const candidate of actionableCandidates) {
+        try {
+          const descriptor = candidate.source === "lab" ? `[lab] ${candidate.name}` : candidate.name;
+          if (candidate.source === "git" && !this.isUnderBuildManagedCleanupRoot(candidate.path, repoRoot, this.getWorktreeBase())) {
+            recordPreserved(candidate, "external-git-worktree");
+            if (verbose && verbosePreserved) {
+              logCleanupMessage(`Preserving external git worktree: ${descriptor}`);
+            }
+            continue;
+          }
+          if (candidate.branchName && (isProtectedPipelineBranch(candidate.branchName, void 0, repoRoot) || candidate.branchName === await this.resolveCurrentBranchName(repoRoot))) {
+            recordPreserved(candidate, "branch-attached-protected-current");
+            if (verbose) {
+              logCleanupMessage(
+                `Preserving protected/current branch-attached worktree: ${descriptor}`
+              );
+            }
+            continue;
+          }
+          if (candidate.missingOnDisk) {
+            if (!dryRun && await this.deregisterMissingWorktree(candidate.path, repoRoot)) {
+              registeredWorktreePaths.delete(canonicalizePath(candidate.path));
+              report.prunedGitWorktreeEntries = (report.prunedGitWorktreeEntries ?? 0) + 1;
+              report.deleted++;
+              report.deletedWorktrees.push(candidate.name);
+              report.deletedWorktreePaths ??= [];
+              report.deletedWorktreePaths.push(candidate.path);
+              if (candidate.source === "lab") report.deletedLabWorktrees.push(candidate.name);
+              continue;
+            }
+            report.skippedUninspectableWorktrees ??= [];
+            report.skippedUninspectableWorktrees.push(candidate.name);
+            recordPreserved(candidate, "missing-registered-path");
+            if (dryRun && verbose) {
+              logCleanupMessage(
+                `[DRY RUN] Preserving missing registration; execute checks this worktree individually: ${candidate.name}`
+              );
+            }
+            continue;
+          }
+          const stats = await stat(candidate.path);
+          const age = Date.now() - stats.mtimeMs;
+          if (age < MIN_WORKTREE_CLEANUP_AGE_MS) {
+            recordPreserved(candidate, "too-recent");
+            continue;
+          }
+          if (age <= maxAge) {
+            recordPreserved(candidate, "too-recent");
+            continue;
+          }
+          if (await isActiveRun(candidate.path)) {
+            recordPreserved(candidate, "active-run");
+            if (verbose) {
+              logCleanupMessage(`Skipping active worktree (live run): ${candidate.name}`);
+            }
+            continue;
+          }
+          const missingGitMetadata = this.shouldFailClosedForMissingGitMetadata(candidate) || includeBrokenMetadata && candidate.source === "standard" && !candidate.registeredGitWorktree && !existsSync(join(candidate.path, ".git"));
+          if (missingGitMetadata && (!includeBrokenMetadata || !this.canCleanBrokenMetadataCandidate(candidate))) {
+            report.skippedUninspectableWorktrees ??= [];
+            report.skippedUninspectableWorktrees.push(candidate.name);
+            recordPreserved(candidate, "uninspectable");
+            if (verbose) {
+              logCleanupMessage(`Skipping uninspectable worktree: ${descriptor}`);
+            }
+            continue;
+          }
+          const changeState = missingGitMetadata ? "broken-gitdir" : await this.inspectWorktreeChangeState(candidate.path);
+          if (changeState === "dirty") {
+            report.skippedDirtyWorktrees ??= [];
+            report.skippedDirtyWorktrees.push(candidate.name);
+            recordPreserved(candidate, "dirty");
+            if (verbose && verbosePreserved) {
+              logCleanupMessage(`Skipping dirty worktree: ${descriptor}`);
+            }
+            continue;
+          }
+          if (changeState === "broken-gitdir" && (!includeBrokenMetadata || !this.canCleanBrokenMetadataCandidate(candidate))) {
+            report.skippedUninspectableWorktrees ??= [];
+            report.skippedUninspectableWorktrees.push(candidate.name);
+            recordPreserved(candidate, "uninspectable");
+            if (verbose) {
+              logCleanupMessage(`Skipping uninspectable worktree: ${descriptor}`);
+            }
+            continue;
+          }
+          if (changeState === "uninspectable") {
+            report.skippedUninspectableWorktrees ??= [];
+            report.skippedUninspectableWorktrees.push(candidate.name);
+            recordPreserved(candidate, "uninspectable");
+            if (verbose) {
+              logCleanupMessage(`Skipping uninspectable worktree: ${descriptor}`);
+            }
+            continue;
+          }
+          if ([...registeredWorktreePaths].some(
+            (registeredPath) => isNestedPath(candidate.path, registeredPath) && existsSync(registeredPath)
+          )) {
+            report.skippedUninspectableWorktrees ??= [];
+            report.skippedUninspectableWorktrees.push(candidate.name);
+            recordPreserved(candidate, "nested-child");
+            if (verbose) {
+              logCleanupMessage(
+                `Skipping parent worktree with registered nested child: ${descriptor}`
+              );
+            }
+            continue;
+          }
+          const size = estimateSize ? await this.getDirSize(candidate.path) : 0;
+          if (dryRun) {
+            if (verbose) {
+              const sizeLabel = estimateSize ? `, ${formatBytes(size)}` : "";
+              const metadataLabel = changeState === "broken-gitdir" ? ", broken Git metadata" : "";
+              logCleanupMessage(
+                `[DRY RUN] Would clean up old worktree: ${descriptor} (${this.formatAge(age)} old${sizeLabel}${metadataLabel})`
+              );
+            }
+            report.deleted++;
+            report.freedBytes += size;
+            report.deletedWorktrees.push(candidate.name);
+            report.deletedWorktreePaths ??= [];
+            report.deletedWorktreePaths.push(candidate.path);
+            if (changeState === "broken-gitdir") {
+              report.deletedBrokenMetadataWorktrees ??= [];
+              report.deletedBrokenMetadataWorktrees.push(candidate.name);
+            }
+            if (candidate.source === "lab") {
+              report.deletedLabWorktrees.push(candidate.name);
+            }
+            continue;
+          }
+          if (verbose) {
+            logCleanupMessage(
+              `Cleaning up old worktree: ${descriptor} (${this.formatAge(age)} old, ${formatBytes(size)})`
+            );
+          }
+          let removed = false;
+          const canFastRemoveRegisteredWorktree = candidate.registeredGitWorktree && candidate.detached && !candidate.branchName;
+          if (candidate.registeredGitWorktree && !canFastRemoveRegisteredWorktree) {
+            const removal = await execa("git", ["worktree", "remove", candidate.path, "--force"], {
+              cwd: repoRoot,
+              stdio: "pipe",
+              reject: false
+            });
+            removed = removal.exitCode === 0;
+          }
+          if (!removed) {
+            const rmResult = await safeRmDir(candidate.path, {
+              protectedPaths: [repoRoot],
+              managedRoots: [
+                this.getWorktreeBase(),
+                resolve(repoRoot, ".build-project/tmp"),
+                resolve(repoRoot, LABS_RELATIVE_PATH),
+                // Previous pools are discovered above, so their worktrees must be deletable.
+                ...this.getPreviousWorktreePools(repoRoot)
+              ],
+              dryRun
+            });
+            if (!rmResult.deleted) {
+              this.logDebug(`SAFETY: ${rmResult.reason}`, new Error("safeRmDir refused"));
+              continue;
+            }
+          }
+          if (!existsSync(candidate.path)) {
+            if (candidate.registeredGitWorktree && !removed && await this.deregisterMissingWorktree(candidate.path, repoRoot)) {
+              registeredWorktreePaths.delete(canonicalizePath(candidate.path));
+              report.prunedGitWorktreeEntries = (report.prunedGitWorktreeEntries ?? 0) + 1;
+            }
+            report.deleted++;
+            report.freedBytes += size;
+            report.deletedWorktrees.push(candidate.name);
+            report.deletedWorktreePaths ??= [];
+            report.deletedWorktreePaths.push(candidate.path);
+            if (changeState === "broken-gitdir") {
+              report.deletedBrokenMetadataWorktrees ??= [];
+              report.deletedBrokenMetadataWorktrees.push(candidate.name);
+            }
+            if (candidate.source === "lab") {
+              report.deletedLabWorktrees.push(candidate.name);
+            }
+            if (candidate.branchName) {
+              try {
+                await enqueueBranchCleanup(candidate.branchName, {
+                  reason: "worktree-cleanup",
+                  queuePath: getBranchCleanupQueuePath(repoRoot),
+                  cwd: repoRoot,
+                  expectedHeadSha: await this.resolveBranchHeadSha(repoRoot, candidate.branchName)
+                });
+              } catch (error) {
+                this.logDebug(
+                  `Failed to queue branch cleanup for ${candidate.branchName}`,
+                  error ?? "unknown error"
+                );
+              }
+            }
+          }
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          if (/ENOENT: no such file or directory, stat /.test(message)) {
+            this.logDebug(
+              `Skipping disappearing worktree candidate during cleanup: ${candidate.name}`,
+              error
+            );
+            continue;
+          }
+          emitWarning(
+            "WS-003",
+            {
+              subsystem: "utils",
+              executionPhase: "cleanup"
+            },
+            {
+              severity: "WARN" /* WARN */,
+              metadata: {
+                worktreeName: candidate.name,
+                error: message,
+                operation: "cleanupWorktree"
+              }
+            }
+          );
+        }
+      }
+      if (report.deleted > 0) {
+        const prefix = dryRun ? "[DRY RUN] Would clean" : "Cleaned";
+        const sizeLabel = estimateSize ? `${dryRun ? "would free" : "freed"} ${formatBytes(report.freedBytes)}` : "size not estimated";
+        logCleanupMessage(`${prefix} ${report.deleted} worktree(s), ${sizeLabel}
+`);
+      }
+      if (verbose && verbosePreserved && report.skippedDirtyWorktrees && report.skippedDirtyWorktrees.length > 0) {
+        logCleanupMessage(
+          `Skipped ${report.skippedDirtyWorktrees.length} dirty worktree(s) with local changes.`
+        );
+      }
+      if (!dryRun && report.deletedBrokenMetadataWorktrees && report.deletedBrokenMetadataWorktrees.length > 0) {
+        logCleanupMessage(
+          `Cleaned ${report.deletedBrokenMetadataWorktrees.length} worktree(s) with broken Git metadata after explicit opt-in.`
+        );
+      }
+      if (!dryRun && (report.prunedGitWorktreeEntries ?? 0) > 0) {
+        logCleanupMessage(`Pruned ${report.prunedGitWorktreeEntries} stale Git worktree entries.`);
+      }
+      if (report.skippedUninspectableWorktrees && report.skippedUninspectableWorktrees.length > 0) {
+        logCleanupMessage(
+          `Skipped ${report.skippedUninspectableWorktrees.length} uninspectable worktree(s) with broken or unreadable Git metadata.`
+        );
+      }
+    } catch (error) {
+      console.error("Worktree cleanup failed:", error);
+    }
+    return report;
+  }
+  /**
+   * Format bytes for human-readable output
+   *
+   * @param bytes Size in bytes
+   * @returns Formatted size string
+   * @private
+   */
+  logDebug(message, error) {
+    if (!readEnv(BUILD_DEBUG).value) return;
+    const errMessage = error instanceof Error ? error.message : String(error);
+    console.debug(`[worktree-cleanup] ${message}: ${errMessage}`);
+  }
+};
+function isInsideGitWorkTree(cwd) {
+  try {
+    const opts = {
+      cwd,
+      timeout: 3e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    };
+    const out = execFileSync("git", ["rev-parse", "--is-inside-work-tree"], opts).toString().trim();
+    return out === "true";
+  } catch {
+    return false;
+  }
+}
+function runWorktreeCleanup() {
+  setImmediate(async () => {
+    try {
+      const manager = new WorktreeCleanupManager();
+      await manager.cleanup();
+      const repoRoot = findProjectRoot(process.cwd());
+      if (repoRoot) {
+        const { runAutomaticBranchCleanup } = await import("./automatic-branch-cleanup-R62X2C5O.js");
+        await runAutomaticBranchCleanup({ repoRoot, lockDir: manager.getWorktreeBase() });
+      }
+    } catch (error) {
+      if (isCleanupLockContentionError(error)) {
+        return;
+      }
+      console.error("Worktree cleanup failed:", error);
+    }
+  });
+}
+
+export {
+  inspectSessionCleanup,
+  cleanupSessionsCategory,
+  getMaxWorktreeAge,
+  WorktreeCleanupManager,
+  runWorktreeCleanup
+};
+//# sourceMappingURL=chunk-UPHU64NB.js.map