@poetic-ai/poetic 1.42.0

package/dist/chunk-NN4PJDHP.js

@@ -0,0 +1,708 @@
+import {
+  normalizePath
+} from "./chunk-ZIPWI2LY.js";
+import {
+  shouldExcludeFile
+} from "./chunk-NS33V3IM.js";
+import {
+  filterWorktreeRunSentinelPaths,
+  filterWorktreeRunSentinelStatusOutput
+} from "./chunk-I5WRT7ZR.js";
+import {
+  execGit
+} from "./chunk-KNDYMVWN.js";
+
+// src/automation/flywheel-git-isolation.ts
+import { execFileSync } from "child_process";
+import * as path from "path";
+import { execa } from "execa";
+var GIT_COMMAND_TIMEOUT_MS = Math.max(
+  3e4,
+  Number.parseInt(process.env.POETIC_GIT_COMMAND_TIMEOUT_MS ?? "", 10) || 12e4
+);
+function getRepoRoot() {
+  try {
+    const gitCommonDir = execFileSync(
+      "git",
+      ["rev-parse", "--path-format=absolute", "--git-common-dir"],
+      {
+        cwd: process.cwd(),
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    ).trim();
+    return path.dirname(gitCommonDir);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `[flywheel-git-isolation] Failed to resolve git repo root from ${process.cwd()}: ${message}`
+    );
+  }
+}
+var TEST_BRANCH_PREFIX = "poetic/flywheel-test/";
+function isMissingWorktreeCwdError(error) {
+  const errnoError = error;
+  const combined = [errnoError.message, errnoError.shortMessage, errnoError.stderr].filter((value) => typeof value === "string" && value.length > 0).join("\n");
+  return /\bcwd\b/i.test(combined) && (typeof errnoError.code === "string" && errnoError.code === "ENOENT" || /\bENOENT\b/i.test(combined) || /no such file or directory/i.test(combined) || /\binvalid\b/i.test(combined));
+}
+async function createStageCheckpoint(stageId, cwd) {
+  if (!cwd || !path.isAbsolute(cwd)) {
+    throw new Error(`createStageCheckpoint requires absolute cwd, got: ${cwd}`);
+  }
+  const startCommit = await getCurrentCommit(cwd);
+  const untrackedFiles = await getUntrackedFiles(cwd);
+  return {
+    stageId,
+    startCommit,
+    untrackedFiles,
+    diff: void 0,
+    // Populated after stage execution
+    endCommit: void 0
+    // Populated if committed
+  };
+}
+async function rollbackToCheckpoint(checkpoint, cwd) {
+  if (!cwd || !path.isAbsolute(cwd)) {
+    throw new Error(`rollbackToCheckpoint requires absolute cwd, got: ${cwd}`);
+  }
+  await execa("git", ["reset", "--hard", checkpoint.startCommit], {
+    cwd,
+    stdio: "pipe",
+    timeout: GIT_COMMAND_TIMEOUT_MS
+  });
+  const currentUntracked = await getUntrackedFiles(cwd);
+  const filesToRemove = currentUntracked.filter((f) => !checkpoint.untrackedFiles.includes(f));
+  if (filesToRemove.length > 0) {
+    await execa("git", ["clean", "-fd", "--", ...filesToRemove], {
+      cwd,
+      stdio: "pipe",
+      timeout: GIT_COMMAND_TIMEOUT_MS
+    });
+  }
+}
+var WorktreeReuseDirtyError = class extends Error {
+  constructor(message, worktreePath, report) {
+    super(message);
+    this.worktreePath = worktreePath;
+    this.report = report;
+    this.name = "WorktreeReuseDirtyError";
+  }
+  worktreePath;
+  report;
+};
+var WorktreeReuseUnavailableError = class extends Error {
+  constructor(message, worktreePath, cause) {
+    super(message);
+    this.worktreePath = worktreePath;
+    this.cause = cause;
+    this.name = "WorktreeReuseUnavailableError";
+  }
+  worktreePath;
+  cause;
+};
+function isNotAGitRepositoryError(error) {
+  if (!error || typeof error !== "object") return false;
+  const messageSource = error.stderr ?? error.message ?? "";
+  const message = typeof messageSource === "string" ? messageSource : String(messageSource);
+  return /not a git repository/i.test(message);
+}
+async function inspectWorktreeCleanliness(worktreePath) {
+  if (!worktreePath || !path.isAbsolute(worktreePath)) {
+    throw new Error(
+      `inspectWorktreeCleanliness requires absolute worktree path, got: ${worktreePath}`
+    );
+  }
+  let statusOut;
+  try {
+    const result = await execa("git", ["status", "--porcelain"], {
+      cwd: worktreePath,
+      stdio: "pipe",
+      timeout: GIT_COMMAND_TIMEOUT_MS
+    });
+    statusOut = result.stdout;
+  } catch (error) {
+    if (isNotAGitRepositoryError(error)) {
+      throw new WorktreeReuseUnavailableError(
+        `Worktree ${worktreePath} is not a git repository; cannot inspect cleanliness for reuse`,
+        worktreePath,
+        error
+      );
+    }
+    throw error;
+  }
+  const dirtyFiles = filterWorktreeRunSentinelStatusOutput(statusOut).split("\n").filter((line) => line.trim().length > 0).map((line) => {
+    const body = line.length > 3 ? line.substring(3).trim() : line.trim();
+    return body.includes(" -> ") ? body.split(" -> ").at(-1) ?? body : body;
+  }).filter((filePath) => !shouldExcludePath(filePath));
+  let addedLines = 0;
+  let removedLines = 0;
+  if (dirtyFiles.length > 0) {
+    try {
+      const { stdout: numstatOut } = await execa("git", ["diff", "--numstat", "HEAD"], {
+        cwd: worktreePath,
+        stdio: "pipe",
+        timeout: GIT_COMMAND_TIMEOUT_MS
+      });
+      for (const line of numstatOut.split("\n")) {
+        if (!line.trim()) continue;
+        const parts = line.split("	");
+        if (parts.length < 3) continue;
+        const filePath = parts[2] ?? "";
+        if (shouldExcludePath(filePath)) continue;
+        const added = Number.parseInt(parts[0] ?? "", 10);
+        const removed = Number.parseInt(parts[1] ?? "", 10);
+        if (Number.isFinite(added)) addedLines += added;
+        if (Number.isFinite(removed)) removedLines += removed;
+      }
+    } catch {
+    }
+  }
+  return {
+    isClean: dirtyFiles.length === 0,
+    dirtyFiles,
+    addedLines,
+    removedLines
+  };
+}
+async function assertWorktreeCleanForReuse(worktreePath, options = {}) {
+  const report = await inspectWorktreeCleanliness(worktreePath);
+  if (report.isClean) {
+    return report;
+  }
+  if (!options.reset) {
+    throw new WorktreeReuseDirtyError(
+      `Refusing to reuse worktree ${worktreePath}: ${report.dirtyFiles.length} uncommitted file(s) (+${report.addedLines}/-${report.removedLines}) from prior attempt`,
+      worktreePath,
+      report
+    );
+  }
+  await execa("git", ["reset", "--hard", "HEAD"], {
+    cwd: worktreePath,
+    stdio: "pipe",
+    timeout: GIT_COMMAND_TIMEOUT_MS
+  });
+  await execa("git", ["clean", "-fd"], {
+    cwd: worktreePath,
+    stdio: "pipe",
+    timeout: GIT_COMMAND_TIMEOUT_MS
+  });
+  const after = await inspectWorktreeCleanliness(worktreePath);
+  if (!after.isClean) {
+    throw new WorktreeReuseDirtyError(
+      `Worktree ${worktreePath} remains dirty after reset (${after.dirtyFiles.length} file(s))`,
+      worktreePath,
+      after
+    );
+  }
+  return after;
+}
+async function getCurrentCommit(cwd) {
+  if (!cwd || !path.isAbsolute(cwd)) {
+    throw new Error(`getCurrentCommit requires absolute cwd, got: ${cwd}`);
+  }
+  const { stdout } = await execa("git", ["rev-parse", "HEAD"], {
+    cwd,
+    stdio: "pipe",
+    timeout: GIT_COMMAND_TIMEOUT_MS
+  });
+  return stdout.trim();
+}
+async function getUntrackedFiles(cwd) {
+  if (!cwd || !path.isAbsolute(cwd)) {
+    throw new Error(`getUntrackedFiles requires absolute cwd, got: ${cwd}`);
+  }
+  const { stdout } = await execa("git", ["ls-files", "--others", "--exclude-standard"], {
+    cwd,
+    stdio: "pipe",
+    timeout: GIT_COMMAND_TIMEOUT_MS
+  });
+  return stdout.split("\n").filter((line) => line.trim().length > 0);
+}
+function normalizeExplicitRepoFilePath(filePath) {
+  const normalized = normalizePath(filePath);
+  if (normalized.length === 0 || normalized === "." || normalized === ".." || normalized.startsWith("../") || normalized.includes("/../") || normalized.endsWith("/") || path.posix.isAbsolute(normalized) || // Windows drive / UNC after normalizePath slash conversion
+  /^[a-zA-Z]:\//.test(normalized) || normalized.startsWith("//")) {
+    return void 0;
+  }
+  return normalized;
+}
+async function getIgnoredExplicitFiles(cwd, paths = []) {
+  const candidates = [
+    ...new Set(
+      paths.map((entry) => normalizeExplicitRepoFilePath(entry)).filter((entry) => Boolean(entry))
+    )
+  ];
+  if (candidates.length === 0) return [];
+  const { stdout } = await execa(
+    "git",
+    ["ls-files", "--others", "--ignored", "--exclude-standard", "--", ...candidates],
+    {
+      cwd,
+      stdio: "pipe",
+      timeout: GIT_COMMAND_TIMEOUT_MS
+    }
+  );
+  return stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+}
+async function deleteBranch(branchName, force = false, cwd) {
+  const result = await execGit(["branch", force ? "-D" : "-d", branchName], {
+    cwd,
+    timeoutMs: GIT_COMMAND_TIMEOUT_MS
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr.trim() || `git branch ${force ? "-D" : "-d"} failed`);
+  }
+}
+async function getChangedFilesSince(fromCommit, cwd, options = {}) {
+  if (!cwd || !path.isAbsolute(cwd)) {
+    throw new Error(`getChangedFilesSince requires absolute cwd, got: ${cwd}`);
+  }
+  const changedFiles = /* @__PURE__ */ new Set();
+  const parseNameStatus = (output) => {
+    for (const line of output.split("\n").filter((l) => l.trim())) {
+      const parts = line.split("	");
+      const status = parts[0]?.[0];
+      if (status === "R" || status === "C") {
+        if (parts[2]) changedFiles.add(parts[2]);
+      } else if (parts[1]) {
+        changedFiles.add(parts[1]);
+      }
+    }
+  };
+  const { stdout: cachedDiffOutput } = await execa(
+    "git",
+    ["diff", "--name-status", "-M", fromCommit, "--cached"],
+    { cwd, stdio: "pipe", timeout: GIT_COMMAND_TIMEOUT_MS }
+  );
+  parseNameStatus(cachedDiffOutput);
+  const { stdout: workingDiffOutput } = await execa(
+    "git",
+    ["diff", "--name-status", "-M", fromCommit],
+    {
+      cwd,
+      stdio: "pipe",
+      timeout: GIT_COMMAND_TIMEOUT_MS
+    }
+  );
+  parseNameStatus(workingDiffOutput);
+  const { stdout: untrackedOutput } = await execa(
+    "git",
+    ["ls-files", "--others", "--exclude-standard"],
+    {
+      cwd,
+      stdio: "pipe",
+      timeout: GIT_COMMAND_TIMEOUT_MS
+    }
+  );
+  for (const file of untrackedOutput.split("\n").filter((l) => l.trim())) {
+    changedFiles.add(file);
+  }
+  for (const file of await getIgnoredExplicitFiles(cwd, options.includeIgnoredPaths)) {
+    changedFiles.add(file);
+  }
+  return filterWorktreeRunSentinelPaths([...changedFiles]);
+}
+var DIFF_EXCLUDE_PATTERNS = [
+  "node_modules",
+  ".cursor",
+  ".vscode",
+  "coverage",
+  "dist",
+  ".poetic/tmp",
+  ".git",
+  "*.log"
+];
+function shouldExcludePath(filePath) {
+  const normalizedPath = normalizePath(filePath);
+  if (shouldExcludeFile(normalizedPath)) {
+    return true;
+  }
+  for (const pattern of DIFF_EXCLUDE_PATTERNS) {
+    if (normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`)) {
+      return true;
+    }
+    if (pattern.startsWith("*") && normalizedPath.endsWith(pattern.slice(1))) {
+      return true;
+    }
+  }
+  return false;
+}
+async function getCleanChangedFiles(fromCommit, cwd) {
+  const allChanges = await getChangedFilesSince(fromCommit, cwd);
+  const changes = [];
+  const excludedSymlinks = [];
+  const excludedPatterns = [];
+  const fs = await import("fs/promises");
+  for (const filePath of allChanges) {
+    if (shouldExcludePath(filePath)) {
+      excludedPatterns.push(filePath);
+      continue;
+    }
+    try {
+      const fullPath = path.join(cwd, filePath);
+      const stats = await fs.lstat(fullPath);
+      if (stats.isSymbolicLink()) {
+        excludedSymlinks.push(filePath);
+        continue;
+      }
+    } catch {
+    }
+    changes.push(filePath);
+  }
+  return {
+    changes,
+    excludedSymlinks,
+    excludedPatterns,
+    isClean: excludedSymlinks.length === 0 && excludedPatterns.length === 0
+  };
+}
+async function getCleanDiff(fromCommit, toCommit = "HEAD", cwd) {
+  const options = {
+    cwd: cwd ?? getRepoRoot(),
+    stdio: "pipe",
+    timeout: GIT_COMMAND_TIMEOUT_MS
+  };
+  const excludeArgs = DIFF_EXCLUDE_PATTERNS.length > 0 ? ["--", ...DIFF_EXCLUDE_PATTERNS.map((p) => `:(exclude)${p}`)] : [];
+  try {
+    const { stdout: diffOutput } = await execa(
+      "git",
+      ["diff", fromCommit, toCommit, ...excludeArgs],
+      options
+    );
+    const { stdout: namesOutput } = await execa(
+      "git",
+      ["diff", "--name-only", fromCommit, toCommit, ...excludeArgs],
+      options
+    );
+    const changedFiles = namesOutput.trim().split("\n").filter((f) => f.length > 0);
+    const { stdout: statOutput } = await execa(
+      "git",
+      ["diff", "--numstat", fromCommit, toCommit, ...excludeArgs],
+      options
+    );
+    let additions = 0;
+    let deletions = 0;
+    for (const line of statOutput.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0) continue;
+      const [addedRaw, removedRaw] = trimmed.split("	");
+      const added = Number.parseInt(addedRaw ?? "", 10);
+      const removed = Number.parseInt(removedRaw ?? "", 10);
+      if (Number.isFinite(added)) additions += added;
+      if (Number.isFinite(removed)) deletions += removed;
+    }
+    return {
+      diff: diffOutput,
+      changedFiles,
+      stats: { additions, deletions }
+    };
+  } catch {
+    return {
+      diff: "",
+      changedFiles: [],
+      stats: { additions: 0, deletions: 0 }
+    };
+  }
+}
+async function getDiff(fromCommit, toCommit = "HEAD") {
+  const { stdout } = await execa("git", ["diff", fromCommit, toCommit], {
+    cwd: getRepoRoot(),
+    stdio: "pipe",
+    timeout: GIT_COMMAND_TIMEOUT_MS
+  });
+  return stdout;
+}
+async function isGitRepository() {
+  try {
+    await execa("git", ["rev-parse", "--git-dir"], {
+      cwd: getRepoRoot(),
+      stdio: "pipe",
+      timeout: GIT_COMMAND_TIMEOUT_MS
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listFlywheelBranches(options) {
+  const { stdout } = await execa("git", ["branch", "--list", "poetic/flywheel*"], {
+    cwd: options?.cwd ?? getRepoRoot(),
+    stdio: "pipe",
+    timeout: GIT_COMMAND_TIMEOUT_MS
+  });
+  const branches = [];
+  const lines = stdout.split("\n").filter((line) => line.trim().length > 0);
+  for (const line of lines) {
+    const name = line.replace(/^[*+]?\s*/, "").trim();
+    if (!name) continue;
+    const isTestBranch = name.startsWith(TEST_BRANCH_PREFIX);
+    if (options?.testOnly && !isTestBranch) continue;
+    let timestamp;
+    let ageDays;
+    const timestampMatch = name.match(/(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2})/);
+    if (timestampMatch?.[1]) {
+      const isoString = timestampMatch[1].replace(/-(\d{2})-(\d{2})$/, ":$1:$2");
+      timestamp = new Date(isoString);
+      if (!Number.isNaN(timestamp.getTime())) {
+        ageDays = Math.floor((Date.now() - timestamp.getTime()) / (1e3 * 60 * 60 * 24));
+      }
+    }
+    branches.push({
+      name,
+      isTestBranch,
+      timestamp,
+      ageDays
+    });
+  }
+  return branches;
+}
+async function cleanupOldFlywheelBranches(olderThanDays, options) {
+  const branches = await listFlywheelBranches({
+    testOnly: options.testOnly,
+    cwd: options.cwd
+  });
+  const toDelete = [];
+  for (const branch of branches) {
+    if (branch.ageDays !== void 0 && branch.ageDays >= olderThanDays) {
+      toDelete.push(branch.name);
+    }
+  }
+  if (!options.dryRun) {
+    for (const branchName of toDelete) {
+      try {
+        await deleteBranch(branchName, true, options.cwd);
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.error(`Failed to delete branch ${branchName}: ${errorMsg}`);
+      }
+    }
+  }
+  return toDelete;
+}
+async function commitWithAllowlist(worktreePath, allowlist, strictMode, commitMessage, stageId, mode, denylist = [], denylistMode = "strict", allowDenylist = [], options) {
+  const { computeCommitFiles, stageAndCommit } = await import("./commit-utils-P7CRJF5N.js");
+  const { isSystemWritePath, normalizePath: normalizePath2 } = await import("./allowlist-utils-23V7TJ3G.js");
+  const { decideStageChangeScope } = await import("./flywheel-scope-decision-ZHKF6ZIN.js");
+  const effectiveMode = mode ?? (strictMode ? "strict" : "off");
+  const normalizedAllowlist = [...new Set(allowlist.map((file) => normalizePath2(file)))];
+  const normalizedDenylist = [...new Set(denylist.map((file) => normalizePath2(file)))];
+  const normalizedAllowDenylist = [...new Set(allowDenylist.map((file) => normalizePath2(file)))];
+  const { eligibleFiles: rawEligibleFiles, allStatusEntries } = await computeCommitFiles({
+    worktreePath,
+    forceIncludeFiles: options?.skipForceInclude ? void 0 : normalizedAllowlist,
+    includeAllUntrackedPaths: true
+  });
+  const systemStatusFiles = allStatusEntries.flatMap(
+    (entry) => [entry.originalPath, entry.path].filter(
+      (file) => typeof file === "string" && isSystemWritePath(file)
+    )
+  );
+  const eligibleFiles = [
+    ...new Set([...rawEligibleFiles, ...systemStatusFiles].map((file) => normalizePath2(file)))
+  ];
+  if (eligibleFiles.length === 0) {
+    return {
+      committed: false,
+      commitSha: null,
+      eligibleFiles: [],
+      filesToCommit: [],
+      reason: "no-changes",
+      mode: effectiveMode
+    };
+  }
+  const mutationOrigin = options?.mutationOrigin ?? "provider";
+  const decision = decideStageChangeScope({
+    changedPaths: eligibleFiles,
+    explicitScope: normalizedAllowlist,
+    allowlistMode: effectiveMode,
+    denylistPolicy: {
+      denylist: normalizedDenylist,
+      mode: denylistMode,
+      allow: normalizedAllowDenylist
+    },
+    mutationOrigin
+  });
+  const violations = decision.allowlistViolations;
+  const denylistViolations = decision.denylistViolations;
+  const systemFiles = mutationOrigin === "coordinator" ? eligibleFiles.filter((file) => isSystemWritePath(file)) : [];
+  if (decision.disposition === "block") {
+    return {
+      committed: false,
+      commitSha: null,
+      eligibleFiles,
+      filesToCommit: [],
+      error: `Stage '${stageId}' modified ${denylistViolations.length} denylisted file(s): ${decision.reason}`,
+      denylistViolations,
+      violations: violations.length > 0 ? violations : void 0,
+      mode: effectiveMode
+    };
+  }
+  if (decision.disposition === "rollback") {
+    const emptyScope = normalizedAllowlist.length === 0;
+    return {
+      committed: false,
+      commitSha: null,
+      eligibleFiles,
+      filesToCommit: [],
+      error: emptyScope ? `Strict mode: stage '${stageId}' changed ${violations.length} files but no allowlist defined` : `Stage '${stageId}' modified ${violations.length} non-allowlisted file(s)`,
+      violations,
+      denylistViolations: denylistViolations.length > 0 ? denylistViolations : void 0,
+      mode: effectiveMode
+    };
+  }
+  const filesToCommit = decision.permittedPaths;
+  if (filesToCommit.length === 0) {
+    return {
+      committed: false,
+      commitSha: null,
+      eligibleFiles,
+      filesToCommit: [],
+      reason: "scope-filtered",
+      violations: violations.length > 0 ? violations : void 0,
+      denylistViolations: denylistViolations.length > 0 ? denylistViolations : void 0,
+      mode: effectiveMode
+    };
+  }
+  const result = await stageAndCommit({
+    worktreePath,
+    filesToStage: filesToCommit,
+    commitMessage,
+    forceAdd: true
+  });
+  return {
+    committed: result.committed,
+    commitSha: result.commitSha ?? null,
+    eligibleFiles,
+    filesToCommit,
+    reason: result.reason,
+    violations: violations.length > 0 ? violations : void 0,
+    denylistViolations: denylistViolations.length > 0 ? denylistViolations : void 0,
+    mode: effectiveMode,
+    systemFiles: systemFiles.length > 0 ? systemFiles : void 0
+  };
+}
+var ConflictError = class extends Error {
+  constructor(message, conflictedFiles) {
+    super(message);
+    this.conflictedFiles = conflictedFiles;
+    this.name = "ConflictError";
+  }
+  conflictedFiles;
+};
+async function abortCherryPickOrReset(worktreePath) {
+  const abortResult = await execa("git", ["cherry-pick", "--abort"], {
+    cwd: worktreePath,
+    reject: false,
+    timeout: GIT_COMMAND_TIMEOUT_MS
+  });
+  if (abortResult.exitCode === 0) {
+    return { abortFailed: false };
+  }
+  const resetResult = await execa("git", ["reset", "--hard", "HEAD"], {
+    cwd: worktreePath,
+    reject: false,
+    timeout: GIT_COMMAND_TIMEOUT_MS
+  });
+  return { abortFailed: resetResult.exitCode !== 0 };
+}
+async function cherryPickCommit(worktreePath, commitSha) {
+  try {
+    const cherryPickResult = await execa("git", ["cherry-pick", commitSha], {
+      cwd: worktreePath,
+      reject: false,
+      timeout: GIT_COMMAND_TIMEOUT_MS
+    });
+    if (cherryPickResult.exitCode === 0) {
+      return;
+    }
+    const { parseGitStatus } = await import("./parse-git-status-PIAF3OTP.js");
+    let statusOutput;
+    try {
+      const statusResult = await execa("git", ["status", "--porcelain"], {
+        cwd: worktreePath,
+        timeout: GIT_COMMAND_TIMEOUT_MS
+      });
+      statusOutput = filterWorktreeRunSentinelStatusOutput(statusResult.stdout);
+    } catch (error) {
+      if (cherryPickResult.exitCode === 0 && isMissingWorktreeCwdError(error)) {
+        return;
+      }
+      throw error;
+    }
+    const statusEntries = parseGitStatus(statusOutput);
+    const conflictedFiles = statusEntries.filter((entry) => {
+      const idx = entry.indexStatus;
+      const wt = entry.worktreeStatus;
+      return idx === "U" || wt === "U" || // Unmerged
+      idx === "A" && wt === "A" || // Both added
+      idx === "D" && wt === "D";
+    }).map((entry) => entry.path);
+    if (conflictedFiles.length > 0) {
+      const { abortFailed } = await abortCherryPickOrReset(worktreePath);
+      const message = `Cherry-pick conflict: ${conflictedFiles.length} file(s) conflicted${abortFailed ? " (WARNING: cherry-pick cleanup failed; worktree may be poisoned)" : ""}`;
+      throw new ConflictError(message, conflictedFiles);
+    }
+    if (cherryPickResult.exitCode !== 0) {
+      const output = `${cherryPickResult.stdout ?? ""}
+${cherryPickResult.stderr ?? ""}`;
+      const isEmptyPick = output.includes("cherry-pick is now empty") || output.includes("The previous cherry-pick is now empty") || output.includes("nothing to commit") || output.includes("previous cherry-pick is now empty");
+      if (isEmptyPick) {
+        const skipResult = await execa("git", ["cherry-pick", "--skip"], {
+          cwd: worktreePath,
+          reject: false,
+          timeout: GIT_COMMAND_TIMEOUT_MS
+        });
+        if (skipResult.exitCode !== 0) {
+          await execa("git", ["cherry-pick", "--abort"], {
+            cwd: worktreePath,
+            reject: false,
+            timeout: GIT_COMMAND_TIMEOUT_MS
+          });
+        }
+        return;
+      }
+      await execa("git", ["cherry-pick", "--abort"], {
+        cwd: worktreePath,
+        reject: false,
+        timeout: GIT_COMMAND_TIMEOUT_MS
+      });
+      throw new Error(`Cherry-pick failed (non-conflict): ${output.trim() || "unknown error"}`);
+    }
+  } catch (error) {
+    if (error instanceof ConflictError) {
+      throw error;
+    }
+    try {
+      await execa("git", ["cherry-pick", "--abort"], {
+        cwd: worktreePath,
+        reject: false,
+        timeout: GIT_COMMAND_TIMEOUT_MS
+      });
+    } catch {
+    }
+    throw new Error(
+      `Cherry-pick failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+export {
+  isMissingWorktreeCwdError,
+  createStageCheckpoint,
+  rollbackToCheckpoint,
+  WorktreeReuseDirtyError,
+  WorktreeReuseUnavailableError,
+  inspectWorktreeCleanliness,
+  assertWorktreeCleanForReuse,
+  getChangedFilesSince,
+  getCleanChangedFiles,
+  getCleanDiff,
+  getDiff,
+  isGitRepository,
+  listFlywheelBranches,
+  cleanupOldFlywheelBranches,
+  commitWithAllowlist,
+  ConflictError,
+  cherryPickCommit
+};
+//# sourceMappingURL=chunk-NN4PJDHP.js.map