@poetic-ai/poetic 1.42.0

package/dist/chunk-7IL4A2PP.js

@@ -0,0 +1,948 @@
+import {
+  getBranchCleanupQueuePath,
+  readBranchCleanupQueue,
+  removeBranchCleanupEntries
+} from "./chunk-TGON4N4O.js";
+import {
+  isEphemeralPoeticBranchDeletionCandidate,
+  isProtectedPipelineBranch,
+  resolveDefaultBranch
+} from "./chunk-XQD2B6BB.js";
+import {
+  isPoeticOwnedBranch,
+  isValidationBranch
+} from "./chunk-34CNP2HB.js";
+
+// src/core/cleanup/branch-cleanup-manager.ts
+import { existsSync } from "fs";
+import { resolve } 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", "--abbrev-ref", "HEAD"], {
+    cwd,
+    reject: false,
+    stdio: "pipe"
+  });
+  const revParseExitCode = revParse.exitCode ?? 0;
+  if (revParseExitCode === 0) {
+    const branch = revParse.stdout.trim();
+    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/branch-cleanup-manager.ts
+var DEFAULT_BRANCH_CLEANUP_AGE_DAYS = 7;
+var STRICT_POETIC_PATTERNS = [
+  // Legacy lab mode worktree branches (pre poetic/wt-* migration)
+  /^lab-[a-f0-9]{8,}-\d{14,}-.*-[a-f0-9]{8}$/,
+  // Backup branches (numeric timestamp)
+  /^backup\/pre-sync-\d{10,}$/,
+  // Legacy Poetic 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();
+  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 = resolve(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) {
+    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 = Date.now() - tipTime;
+      if (age < thresholdMs * 2) {
+        return /* @__PURE__ */ new Date();
+      }
+    }
+    return new Date(lastActivity || Date.now());
+  }
+  /**
+   * Check if branch name matches any protected pattern
+   */
+  isProtectedBranch(branch) {
+    return isProtectedPipelineBranch(branch);
+  }
+  /**
+   * Check if branch matches cleanup patterns
+   */
+  matchesCleanupPattern(branch, includeTestBranches) {
+    if (isPoeticOwnedBranch(branch)) {
+      return true;
+    }
+    for (const pattern of STRICT_POETIC_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() {
+    const { stdout } = await execa2(
+      "git",
+      ["for-each-ref", "--format=%(refname:short)", "refs/heads/"],
+      { cwd: this.cwd, stdio: "pipe" }
+    );
+    return stdout.trim().split("\n").filter(Boolean);
+  }
+  /**
+   * 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
+    };
+    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();
+    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();
+    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);
+    if (worktreePath) {
+      if (existsSync(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 (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 (!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);
+    const ageDays = Math.floor((Date.now() - 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
+      }
+    };
+  }
+  /**
+   * Archive branches (move to poetic/archive/ namespace)
+   * Returns the actual result after execution
+   */
+  async archive(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
+    };
+    const analysis = await this.analyze(opts);
+    if (opts.dryRun) {
+      return analysis;
+    }
+    const archiveCount = analysis.branches.filter((b) => b.action === "archive").length;
+    if (opts.confirm !== archiveCount) {
+      analysis.errors.push(
+        `Confirmation mismatch: --confirm ${opts.confirm ?? "not provided"} but ${archiveCount} branches to archive. Use --confirm ${archiveCount} to proceed.`
+      );
+      return analysis;
+    }
+    analysis.mode = "executed";
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10).replace(/-/g, "");
+    const successfullyArchivedQueuedBranches = [];
+    for (const branch of analysis.branches) {
+      if (branch.action !== "archive") continue;
+      const archiveName = `poetic/archive/${timestamp}/${branch.name}`;
+      try {
+        await execa2("git", ["branch", "-m", "--", branch.name, archiveName], {
+          cwd: this.cwd,
+          stdio: "pipe"
+        });
+        branch.reason = `archived 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 (!opts.dryRun && 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 poetic/* pattern
+   * SAFETY: Only returns poetic/* branches to prevent accidental deletion of human work
+   */
+  async getRemotePoeticBranches(remote = "origin") {
+    try {
+      const { stdout } = await execa2(
+        "git",
+        ["for-each-ref", "--format=%(refname:short)", `refs/remotes/${remote}/poetic/*`],
+        { 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 poetic/* 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
+    };
+    const remoteBranches = await this.getRemotePoeticBranches(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}`;
+    if (branch.startsWith("poetic/archive/")) {
+      return {
+        name: branch,
+        fullRef,
+        action: "skip",
+        reason: "archive branch (use prune-archives)"
+      };
+    }
+    if (branch.startsWith("poetic/preflight/")) {
+      return {
+        name: branch,
+        fullRef,
+        action: "skip",
+        reason: "preflight branch"
+      };
+    }
+    if (!isEphemeralPoeticBranchDeletionCandidate(branch)) {
+      const reason = branch.startsWith("poetic/flywheel/") || branch.startsWith("poetic/flywheel-test/") ? "flywheel branch (not ephemeral)" : "not a recognized ephemeral poetic 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 poetic/* 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,
+  DEFAULT_BRANCH_CLEANUP_AGE_DAYS,
+  BranchCleanupManager,
+  createBranchCleanupManager
+};
+//# sourceMappingURL=chunk-7IL4A2PP.js.map