@poetic-ai/poetic 1.42.0

package/dist/chunk-DF5SLDE4.js

@@ -0,0 +1,966 @@
+import {
+  enqueueBranchCleanup,
+  getBranchCleanupQueuePath
+} from "./chunk-TGON4N4O.js";
+import {
+  CLEANUP_LOCK_FILENAME,
+  describeCleanupLockState,
+  formatCleanupLockContentionMessage,
+  isActiveRun,
+  isCleanupLockContentionError,
+  tryWithCleanupLock,
+  withCleanupLock
+} from "./chunk-I5WRT7ZR.js";
+import {
+  pruneGitWorktreeEntries
+} from "./chunk-5EERLVZB.js";
+import {
+  isProtectedPipelineBranch
+} from "./chunk-XQD2B6BB.js";
+import {
+  formatBytes
+} from "./chunk-JLS65NUQ.js";
+import {
+  isQuietOutputRequested
+} from "./chunk-FKAUPHMR.js";
+import {
+  LabPathResolver
+} from "./chunk-7GDRQBQC.js";
+import {
+  findProjectRoot
+} from "./chunk-L6OM4A22.js";
+import {
+  canonicalizePath,
+  safeRmDir
+} from "./chunk-G4THLFV3.js";
+import {
+  resolveWorktreeBase
+} from "./chunk-UUH2RVKS.js";
+import {
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+import {
+  POETIC_DEBUG,
+  POETIC_WORKTREE_TTL_DAYS,
+  readEnv,
+  readRawEnv
+} from "./chunk-5DLKYTQX.js";
+
+// 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 = ".poetic/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(dirPath, 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] === ".poetic" && tail[1] === "labs" && tail[3] === "runs" && tail[5] === "worktrees";
+}
+function getMaxWorktreeAge() {
+  const raw = readRawEnv(POETIC_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: "POETIC_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 .poetic/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 Poetic 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, ".poetic/tmp/worktrees");
+    if (resolve(this.getWorktreeBase()) === legacyWorktreeBase) return;
+    await this.populateCandidatesFromDir(legacyWorktreeBase, "standard", map, labPaths);
+  }
+  /**
+   * Discover stale worktree-shaped directories that escaped the standard
+   * .poetic/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, ".poetic/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 Poetic-managed cleanup root.
+   * External manual worktrees registered in Git but outside these roots are preserved.
+   */
+  isUnderPoeticManagedCleanupRoot(candidatePath, repoRoot, worktreeBase) {
+    const resolved = resolve(candidatePath);
+    if (isPathWithinDir(resolved, resolve(worktreeBase))) {
+      return true;
+    }
+    if (isPathWithinDir(resolved, resolve(repoRoot, LABS_RELATIVE_PATH)) || isCanonicalLabWorktreePath(resolved)) {
+      return true;
+    }
+    return isPathWithinDir(resolved, resolve(repoRoot, ".poetic/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"
+      });
+      const lines = stdout.split("\n");
+      let current = null;
+      const flushCurrent = () => {
+        if (current) {
+          entries.push(current);
+          current = null;
+        }
+      };
+      for (const line of lines) {
+        if (line.startsWith("worktree ")) {
+          flushCurrent();
+          current = {
+            path: resolve(repoRoot, line.substring("worktree ".length).trim()),
+            detached: false
+          };
+        } else if (line.startsWith("branch ") && current) {
+          const branchRef = line.substring("branch ".length).trim();
+          current.branchName = branchRef.replace(/^refs\/heads\//, "");
+        } else if (line === "detached" && current) {
+          current.detached = true;
+        } else if (line.trim() === "") {
+          flushCurrent();
+        }
+      }
+      flushCurrent();
+    } 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))
+    );
+    for (const entry of gitEntries) {
+      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 [path, _candidate] of candidateMap) {
+      if (canonicalizePath(path) === canonicalRoot) {
+        candidateMap.delete(path);
+      }
+    }
+    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 === void 0 || result.exitCode === 0) {
+        return (result?.stdout ?? "").trim().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;
+  }
+  /**
+   * 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 pruneEvery = Math.max(1, options?.pruneEvery ?? 50);
+    const limit = Math.max(0, Math.floor(options?.limit ?? 0));
+    const estimateSize = options?.estimateSize ?? true;
+    const includeBrokenMetadata = options?.includeBrokenMetadata ?? false;
+    let registeredCleanupsSincePrune = 0;
+    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: []
+    };
+    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 {
+      let { repoRoot, candidates, registeredWorktreePaths } = await this.gatherWorktreeCandidates(includeBrokenMetadata);
+      const pruneGitRegistryForRepo = async (force = false) => {
+        if (dryRun) return;
+        if (!force && registeredCleanupsSincePrune < pruneEvery) return;
+        registeredCleanupsSincePrune = 0;
+        const entriesBeforePrune = await this.discoverGitWorktreeEntries(repoRoot);
+        const missingBeforePrune = entriesBeforePrune.filter(
+          (entry) => !existsSync(entry.path)
+        ).length;
+        let result = await pruneGitWorktreeEntries({
+          cwd: repoRoot,
+          expireNow: true,
+          verbose: true
+        });
+        let refreshedEntries = await this.discoverGitWorktreeEntries(repoRoot);
+        const stillMissingAfterPrune = () => refreshedEntries.some((entry) => !existsSync(entry.path));
+        for (const delayMs of [250, 750, 1500]) {
+          if (result.prunedEntries === 0 || !stillMissingAfterPrune()) {
+            break;
+          }
+          await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+          const retryResult = await pruneGitWorktreeEntries({
+            cwd: repoRoot,
+            expireNow: true,
+            verbose: true
+          });
+          result = {
+            stdout: `${result.stdout}
+${retryResult.stdout}`,
+            stderr: `${result.stderr}
+${retryResult.stderr}`,
+            prunedEntries: result.prunedEntries + retryResult.prunedEntries
+          };
+          refreshedEntries = await this.discoverGitWorktreeEntries(repoRoot);
+        }
+        const missingAfterPrune = refreshedEntries.filter(
+          (entry) => !existsSync(entry.path)
+        ).length;
+        const observedPrunedEntries = missingBeforePrune > 0 ? Math.max(0, missingBeforePrune - missingAfterPrune) : result.prunedEntries;
+        report.prunedGitWorktreeEntries = (report.prunedGitWorktreeEntries ?? 0) + observedPrunedEntries;
+        registeredWorktreePaths.clear();
+        for (const entry of refreshedEntries) {
+          registeredWorktreePaths.add(canonicalizePath(entry.path));
+        }
+      };
+      if (candidates.length === 0) {
+        return report;
+      }
+      if (!dryRun) {
+        const missingCandidates = candidates.filter((candidate) => candidate.missingOnDisk);
+        if (missingCandidates.length > 0) {
+          await pruneGitRegistryForRepo(true);
+          const prunedMissingPaths = /* @__PURE__ */ new Set();
+          for (const candidate of missingCandidates) {
+            const canonicalPath = canonicalizePath(candidate.path);
+            if (!registeredWorktreePaths.has(canonicalPath)) {
+              prunedMissingPaths.add(canonicalPath);
+              report.deleted++;
+              report.deletedWorktrees.push(candidate.name);
+              report.deletedWorktreePaths ??= [];
+              report.deletedWorktreePaths.push(candidate.path);
+            }
+          }
+          if (prunedMissingPaths.size > 0) {
+            candidates = candidates.filter(
+              (candidate) => !prunedMissingPaths.has(canonicalizePath(candidate.path))
+            );
+          }
+        }
+      }
+      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 {
+          if (candidate.missingOnDisk) {
+            report.skippedUninspectableWorktrees ??= [];
+            report.skippedUninspectableWorktrees.push(candidate.name);
+            recordPreserved(candidate, "missing-registered-path");
+            if (dryRun && verbose) {
+              logCleanupMessage(
+                `[DRY RUN] Would preserve missing registered worktree until Git registry prune confirms removal: ${candidate.name}`
+              );
+            }
+            continue;
+          }
+          const stats = await stat(candidate.path);
+          const age = Date.now() - stats.mtimeMs;
+          if (age < MIN_WORKTREE_CLEANUP_AGE_MS) {
+            if (dryRun) {
+              recordPreserved(candidate, "too-recent");
+            }
+            continue;
+          }
+          if (age <= maxAge) {
+            if (dryRun) {
+              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 descriptor = candidate.source === "lab" ? `[lab] ${candidate.name}` : candidate.name;
+          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 (candidate.source === "git" && !this.isUnderPoeticManagedCleanupRoot(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) || candidate.branchName === await this.resolveCurrentBranchName(repoRoot))) {
+            recordPreserved(candidate, "branch-attached-protected-current");
+            if (verbose) {
+              logCleanupMessage(
+                `Preserving protected/current branch-attached 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;
+            registeredCleanupsSincePrune++;
+            await pruneGitRegistryForRepo();
+          }
+          if (!removed) {
+            const rmResult = await safeRmDir(candidate.path, {
+              protectedPaths: [repoRoot],
+              managedRoots: [
+                this.getWorktreeBase(),
+                resolve(repoRoot, ".poetic/tmp"),
+                resolve(repoRoot, LABS_RELATIVE_PATH)
+              ],
+              dryRun
+            });
+            if (!rmResult.deleted) {
+              this.logDebug(`SAFETY: ${rmResult.reason}`, new Error("safeRmDir refused"));
+              continue;
+            }
+          }
+          if (!existsSync(candidate.path)) {
+            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),
+                  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 (!dryRun && report.deleted > 0) {
+        await pruneGitRegistryForRepo(true);
+      }
+      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(POETIC_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();
+    } catch (error) {
+      if (isCleanupLockContentionError(error)) {
+        return;
+      }
+      console.error("Worktree cleanup failed:", error);
+    }
+  });
+}
+
+export {
+  getMaxWorktreeAge,
+  WorktreeCleanupManager,
+  runWorktreeCleanup
+};
+//# sourceMappingURL=chunk-DF5SLDE4.js.map