@poetic-ai/poetic 1.42.0

package/dist/chunk-BDATUDDJ.js

@@ -0,0 +1,992 @@
+import {
+  resolveRepairArtifactPolicy
+} from "./chunk-XHEKQENB.js";
+import {
+  aggregateResolverOutcomes,
+  classifyResolverCommand
+} from "./chunk-PL37JDNA.js";
+import {
+  captureCurrentWorkspaceTreeIdentity
+} from "./chunk-NSHASMZZ.js";
+import {
+  FileLockCompromisedError,
+  acquireFencedFileLock,
+  ensureLockTargetFile
+} from "./chunk-UHT2KRG5.js";
+import {
+  isCompeteNonInteractiveEnvironment
+} from "./chunk-A722DEVA.js";
+import {
+  parseDiffGitHeaderPaths,
+  parseUnifiedDiffPathLine
+} from "./chunk-C3L6YQ7P.js";
+import {
+  shouldExcludeFile
+} from "./chunk-NS33V3IM.js";
+import {
+  changedFilesRequireVerification,
+  resolveVerificationChannelScope
+} from "./chunk-KP6YILMU.js";
+import {
+  readArtifactDiffFromManifestPath
+} from "./chunk-XGYF2QMZ.js";
+import {
+  runVerificationCommand
+} from "./chunk-D5RYINO7.js";
+import {
+  mkPoeticTempDir
+} from "./chunk-C57KJOUQ.js";
+import {
+  execGit
+} from "./chunk-KNDYMVWN.js";
+import {
+  DEFAULT_TIMEOUT_MS
+} from "./chunk-LAMKBTXX.js";
+import {
+  safeRmDir
+} from "./chunk-G4THLFV3.js";
+import {
+  POETIC_ALLOW_OFF_SCOPE_REPAIR,
+  readEnv
+} from "./chunk-5DLKYTQX.js";
+
+// src/core/compete/apply-completion-mode.ts
+import { execFileSync } from "child_process";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join as join3, posix } from "path";
+
+// src/core/git/checkout-mutation-lock.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+var CHECKOUT_MUTATION_LOCK_STALE_MS = 12e4;
+var CHECKOUT_MUTATION_LOCK_RETRIES = 120;
+var CHECKOUT_MUTATION_LOCK_MIN_TIMEOUT_MS = 250;
+var CHECKOUT_MUTATION_LOCK_MAX_TIMEOUT_MS = 2e3;
+var CHECKOUT_MUTATION_LOCK_BACKOFF_FACTOR = 1.5;
+function getCheckoutMutationLockTarget(projectRoot) {
+  return path.join(projectRoot, ".poetic", "merge-apply", ".apply.lock");
+}
+async function resolveCheckoutMutationLockRoot(projectRoot) {
+  try {
+    return await fs.realpath(projectRoot);
+  } catch {
+    return projectRoot;
+  }
+}
+async function acquireCheckoutMutationLock(projectRoot) {
+  const canonicalRoot = await resolveCheckoutMutationLockRoot(projectRoot);
+  const lockTarget = getCheckoutMutationLockTarget(canonicalRoot);
+  try {
+    await fs.mkdir(path.dirname(lockTarget), { recursive: true });
+    await ensureLockTargetFile(lockTarget);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to prepare checkout mutation lock at ${lockTarget}: ${msg}`);
+  }
+  return acquireFencedFileLock(lockTarget, {
+    stale: CHECKOUT_MUTATION_LOCK_STALE_MS,
+    realpath: false,
+    retries: {
+      retries: CHECKOUT_MUTATION_LOCK_RETRIES,
+      minTimeout: CHECKOUT_MUTATION_LOCK_MIN_TIMEOUT_MS,
+      maxTimeout: CHECKOUT_MUTATION_LOCK_MAX_TIMEOUT_MS,
+      factor: CHECKOUT_MUTATION_LOCK_BACKOFF_FACTOR
+    },
+    description: "Checkout mutation lock"
+  });
+}
+
+// src/core/git/untracked-intent-index.ts
+import { copyFile, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { isAbsolute, join as join2 } from "path";
+var NO_INTENT_INDEX = {
+  untrackedPaths: [],
+  dispose: async () => {
+  }
+};
+async function listAddableUntrackedFiles(params) {
+  const result = await execGit(["ls-files", "--others", "--exclude-standard", "-z"], {
+    cwd: params.worktreePath,
+    timeoutMs: params.timeoutMs
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `git ls-files --others failed (exit ${result.exitCode}): ${result.stderr.trim() || "unknown error"}`
+    );
+  }
+  return result.stdout.split("\0").filter((entry) => entry.length > 0).filter((entry) => !entry.endsWith("/"));
+}
+async function resolveIndexPath(worktreePath, timeoutMs) {
+  const absolute = await execGit(["rev-parse", "--path-format=absolute", "--git-path", "index"], {
+    cwd: worktreePath,
+    timeoutMs
+  });
+  if (absolute.exitCode === 0 && absolute.stdout.trim()) {
+    return absolute.stdout.trim();
+  }
+  const relative = await execGit(["rev-parse", "--git-path", "index"], {
+    cwd: worktreePath,
+    timeoutMs
+  });
+  const reported = relative.stdout.trim();
+  if (relative.exitCode !== 0 || !reported) {
+    throw new Error(
+      `git rev-parse --git-path index failed (exit ${relative.exitCode}): ${relative.stderr.trim() || "unknown error"}`
+    );
+  }
+  return isAbsolute(reported) ? reported : join2(worktreePath, reported);
+}
+async function prepareUntrackedIntentIndex(params) {
+  const worktreePath = params.worktreePath.trim();
+  if (!worktreePath) {
+    throw new Error("untracked intent-to-add index requires a worktree path");
+  }
+  const untrackedPaths = await listAddableUntrackedFiles({
+    worktreePath,
+    timeoutMs: params.timeoutMs
+  });
+  if (untrackedPaths.length === 0) {
+    return NO_INTENT_INDEX;
+  }
+  const realIndexPath = await resolveIndexPath(worktreePath, params.timeoutMs);
+  const tempDir = await mkPoeticTempDir("winner-intent-index");
+  const dispose = async () => {
+    try {
+      await safeRmDir(tempDir, {
+        protectedPaths: [tmpdir()],
+        managedRoots: [tmpdir()]
+      });
+    } catch {
+    }
+  };
+  try {
+    const indexPath = join2(tempDir, "index");
+    await copyFile(realIndexPath, indexPath);
+    const pathspecFile = join2(tempDir, "pathspecs");
+    await writeFile(
+      pathspecFile,
+      `${untrackedPaths.map((entry) => `:(literal)${entry}`).join("\0")}\0`,
+      "utf8"
+    );
+    const addResult = await execGit(
+      [
+        "add",
+        "--intent-to-add",
+        `--pathspec-from-file=${pathspecFile}`,
+        "--pathspec-file-nul",
+        "--"
+      ],
+      {
+        cwd: worktreePath,
+        timeoutMs: params.timeoutMs,
+        // Writes land in the COPY, never the worktree's own index.
+        env: { GIT_INDEX_FILE: indexPath }
+      }
+    );
+    if (addResult.exitCode !== 0) {
+      throw new Error(
+        `git add --intent-to-add failed (exit ${addResult.exitCode}): ${addResult.stderr.trim() || "unknown error"}`
+      );
+    }
+    return { indexPath, untrackedPaths, dispose };
+  } catch (error) {
+    await dispose();
+    throw error;
+  }
+}
+
+// src/core/compete/apply-completion-mode.ts
+var COMPETE_DIFF_BINARY_FLAGS = ["--binary", "--full-index"];
+var COMPETE_GIT_APPLY_WHITESPACE_FLAGS = ["--whitespace=nowarn"];
+var COMPETE_DIFF_MAX_BUFFER_BYTES = 256 * 1024 * 1024;
+var TRUNCATED_DIFF_MARKERS = [
+  /diff truncated/i,
+  /^\.\.\. \[diff truncated(?:[^\]]*)\](?:[;,]|$)/im,
+  /^\[Note: .*diff truncated.*\]$/im,
+  /^NOTE: Diff truncated/im,
+  /^\.\.\.\[output truncated:/im
+];
+function isRecoverableCompetitionDiff(diff) {
+  if (diff.trim().length === 0) return false;
+  return !TRUNCATED_DIFF_MARKERS.some((marker) => marker.test(diff));
+}
+var PR_REMOTE_OP_TIMEOUT_MS = 3e5;
+function resolveEffectiveCompletionMode(mode, context) {
+  let effectiveMode = mode === "none" ? "isolated" : mode;
+  if (effectiveMode === "auto") {
+    if (context.autoModePreference !== void 0) {
+      effectiveMode = context.autoModePreference;
+    } else {
+      effectiveMode = "isolated";
+    }
+  }
+  if (context.createPr === false && effectiveMode === "pr") {
+    effectiveMode = "isolated";
+  }
+  return effectiveMode;
+}
+var CompletionModeCancelledError = class extends Error {
+  constructor(mode, variantId) {
+    super(`completion-mode=${mode} cancelled by user for ${variantId}`);
+    this.name = "CompletionModeCancelledError";
+  }
+};
+function getBranchModeAckPath(projectRoot) {
+  return join3(projectRoot, ".poetic", "state", "branch-mode-ack");
+}
+function hasBranchModeAck(projectRoot) {
+  return existsSync(getBranchModeAckPath(projectRoot));
+}
+function writeBranchModeAck(projectRoot) {
+  const ackPath = getBranchModeAckPath(projectRoot);
+  mkdirSync(join3(projectRoot, ".poetic", "state"), { recursive: true });
+  writeFileSync(ackPath, (/* @__PURE__ */ new Date()).toISOString(), "utf8");
+}
+function isWorkingTreeClean(projectRoot) {
+  try {
+    const output = execFileSync("git", ["status", "--porcelain", "--untracked-files=all"], {
+      cwd: projectRoot,
+      encoding: "utf8"
+    });
+    return parsePorcelainChangedFiles(output, { includeRenameSources: true }).every(
+      (filePath) => filePath === ".poetic/merge-apply" || filePath.startsWith(".poetic/merge-apply/")
+    );
+  } catch {
+    return false;
+  }
+}
+function resolveWinnerBranchName(winner) {
+  if (winner.branchName?.trim()) {
+    return winner.branchName.trim();
+  }
+  if (!winner.worktreePath) {
+    return void 0;
+  }
+  try {
+    const output = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: winner.worktreePath,
+      encoding: "utf8"
+    }).trim();
+    if (!output || output === "HEAD") {
+      return void 0;
+    }
+    return output;
+  } catch {
+    return void 0;
+  }
+}
+function readGitOutput(projectRoot, args) {
+  try {
+    const output = execFileSync("git", args, {
+      cwd: projectRoot,
+      encoding: "utf8"
+    }).trim();
+    return output || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function normalizePatchForGitApply(patch) {
+  return patch.endsWith("\n") ? patch : `${patch}
+`;
+}
+function readGitHead(projectRoot) {
+  return readGitOutput(projectRoot, ["rev-parse", "HEAD"]);
+}
+function readGitBranch(projectRoot) {
+  const branch = readGitOutput(projectRoot, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  return branch && branch !== "HEAD" ? branch : void 0;
+}
+function readWinnerHead(winner, projectRoot) {
+  if (winner.worktreePath) {
+    const worktreeHead = readGitHead(winner.worktreePath);
+    if (worktreeHead) return worktreeHead;
+  }
+  const branchName = resolveWinnerBranchName(winner);
+  return branchName ? readGitOutput(projectRoot, ["rev-parse", branchName]) : void 0;
+}
+function parsePorcelainChangedFiles(statusOutput, options = {}) {
+  const files = /* @__PURE__ */ new Set();
+  const unquote = (value) => value.replace(/^"|"$/g, "");
+  for (const line of statusOutput.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    const pathPart = line.slice(3).trim();
+    if (!pathPart) continue;
+    if (pathPart.includes(" -> ")) {
+      const segments = pathPart.split(" -> ");
+      const destination = segments.pop() ?? pathPart;
+      files.add(unquote(destination));
+      if (options.includeRenameSources) {
+        for (const source of segments) {
+          if (source.trim()) files.add(unquote(source.trim()));
+        }
+      }
+      continue;
+    }
+    files.add(unquote(pathPart));
+  }
+  return [...files].sort();
+}
+function buildPrBody(winner, context) {
+  const lines = ["## Summary", `Poetic selected \`${winner.variantId}\` as the winning variant.`];
+  if (context.taskId) {
+    lines.push("", `- Task ID: \`${context.taskId}\``);
+  }
+  if (context.resolvedConfig) {
+    lines.push(`- Judge: \`${context.resolvedConfig.judge}\``);
+    lines.push(`- Completion mode: \`${context.resolvedConfig.completionMode}\``);
+  }
+  if (context.allVariants && context.allVariants.length > 0) {
+    lines.push(`- Variants evaluated: ${context.allVariants.length}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function parsePrNumberFromGhCreateOutput(output) {
+  const trimmed = String(output).trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const githubUrlMatch = trimmed.match(/\/pull\/(\d+)(?:\b|$)/);
+  if (githubUrlMatch?.[1]) {
+    return Number.parseInt(githubUrlMatch[1], 10);
+  }
+  const hashMatch = trimmed.match(/#(\d+)\b/);
+  if (hashMatch?.[1]) {
+    return Number.parseInt(hashMatch[1], 10);
+  }
+  return void 0;
+}
+async function applyIsolated(winner, context) {
+  if (winner.worktreePath) {
+    console.log(`Winner retained at: ${winner.worktreePath} (no target changes applied)`);
+  } else {
+    console.log(`Winner: ${winner.variantId} (retained; no target changes applied)`);
+  }
+  const classification = winner.repairOutcome?.classification;
+  if (classification === "off_scope") {
+    console.log(`Final artifact: ${winner.repairOutcome?.finalArtifactTrust ?? "quarantined"}`);
+    console.log("Judge verdict applies to final artifact: no");
+  } else if (classification === "unknown") {
+    console.log("Final artifact: unknown repair scope");
+  }
+  context.onApplied?.({
+    mode: "isolated",
+    variantId: winner.variantId,
+    taskId: context.taskId
+  });
+}
+async function assertLiveWorkspaceMatchesAcceptedArtifact(winner, mode) {
+  if (!winner.worktreePath || !winner.acceptedWorkspaceTreeSha) {
+    return;
+  }
+  const currentSourceTreeSha = await captureCurrentWorkspaceTreeIdentity(winner.worktreePath);
+  if (currentSourceTreeSha !== winner.acceptedWorkspaceTreeSha) {
+    throw new Error(
+      `completion-mode=${mode}: live winner workspace no longer matches the accepted judged artifact (${winner.acceptedWorkspaceTreeSha} -> ${currentSourceTreeSha}). Refusing stale or expanded application.`
+    );
+  }
+}
+async function applyPr(winner, context) {
+  const branchName = resolveWinnerBranchName(winner);
+  if (!branchName) {
+    console.warn("completion-mode=pr: winner has no branch; falling back to isolated.");
+    await applyIsolated(winner, context);
+    return;
+  }
+  winner.branchName = branchName;
+  await assertLiveWorkspaceMatchesAcceptedArtifact(winner, "pr");
+  console.log(`Pushing winning branch: ${branchName}`);
+  try {
+    const pushFromWinnerHead = Boolean(winner.worktreePath);
+    execFileSync(
+      "git",
+      pushFromWinnerHead ? ["push", "origin", `HEAD:refs/heads/${branchName}`] : ["push", "origin", branchName],
+      {
+        cwd: winner.worktreePath ?? context.projectRoot,
+        stdio: "inherit",
+        // Bound the push so it cannot hang forever on a credential/auth prompt
+        // (FIX #7). Other apply git calls already use 30s/60s timeouts.
+        timeout: PR_REMOTE_OP_TIMEOUT_MS,
+        // Fail fast instead of blocking on an interactive credential prompt.
+        env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+      }
+    );
+    const prCreateOutput = execFileSync(
+      "gh",
+      [
+        "pr",
+        "create",
+        "--head",
+        branchName,
+        "--title",
+        `Poetic: ${winner.variantId} wins`,
+        "--body",
+        buildPrBody(winner, context)
+      ],
+      {
+        cwd: context.projectRoot,
+        encoding: "utf8",
+        // Bound `gh pr create` so it cannot hang forever on an interactive gh
+        // auth/login prompt (FIX #7).
+        timeout: PR_REMOTE_OP_TIMEOUT_MS,
+        // Tell gh this is non-interactive so a missing credential fails fast
+        // rather than blocking on a prompt.
+        env: { ...process.env, GH_PROMPT_DISABLED: "1" }
+      }
+    );
+    const prNumber = parsePrNumberFromGhCreateOutput(prCreateOutput);
+    if (typeof prNumber === "number" && Number.isFinite(prNumber)) {
+      winner.prNumber = prNumber;
+    }
+    console.log(`Pull request created for ${winner.variantId}`);
+    context.onApplied?.({
+      mode: "pr",
+      variantId: winner.variantId,
+      taskId: context.taskId,
+      prNumber
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`Failed to create PR: ${msg}`);
+    throw err;
+  }
+}
+function parseAddedFilePathsFromPatch(patch) {
+  const lines = patch.split("\n");
+  const added = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === "--- /dev/null" || line?.startsWith("--- /dev/null	")) {
+      const next = lines[i + 1];
+      if (next?.startsWith("+++ ")) {
+        const decoded = decodePatchPath(next.slice(4));
+        if (decoded) {
+          added.push(decoded);
+        }
+      }
+    }
+  }
+  return added;
+}
+function decodeCQuotedPath(body) {
+  const bytes = [];
+  for (let i = 0; i < body.length; i++) {
+    const ch = body[i] ?? "";
+    if (ch !== "\\") {
+      for (const b of Buffer.from(ch, "utf8")) {
+        bytes.push(b);
+      }
+      continue;
+    }
+    const next = body[i + 1];
+    if (next === void 0) {
+      bytes.push(92);
+      continue;
+    }
+    if (next >= "0" && next <= "7") {
+      let oct = "";
+      let j = i + 1;
+      while (j < body.length && oct.length < 3) {
+        const digit = body[j] ?? "";
+        if (digit < "0" || digit > "7") {
+          break;
+        }
+        oct += digit;
+        j++;
+      }
+      bytes.push(Number.parseInt(oct, 8) & 255);
+      i = j - 1;
+      continue;
+    }
+    switch (next) {
+      case "\\":
+        bytes.push(92);
+        break;
+      case '"':
+        bytes.push(34);
+        break;
+      case "t":
+        bytes.push(9);
+        break;
+      case "n":
+        bytes.push(10);
+        break;
+      case "r":
+        bytes.push(13);
+        break;
+      case "f":
+        bytes.push(12);
+        break;
+      case "b":
+        bytes.push(8);
+        break;
+      case "v":
+        bytes.push(11);
+        break;
+      case "a":
+        bytes.push(7);
+        break;
+      default:
+        for (const b of Buffer.from(next, "utf8")) {
+          bytes.push(b);
+        }
+        break;
+    }
+    i++;
+  }
+  return Buffer.from(bytes).toString("utf8");
+}
+function decodePatchPath(field) {
+  let raw = field.split("	")[0]?.trim() ?? "";
+  if (!raw || raw === "/dev/null") {
+    return void 0;
+  }
+  if (raw.startsWith('"') && raw.endsWith('"') && raw.length >= 2) {
+    raw = decodeCQuotedPath(raw.slice(1, -1));
+  }
+  if (raw.startsWith("a/") || raw.startsWith("b/")) {
+    raw = raw.slice(2);
+  }
+  return raw.length > 0 ? raw : void 0;
+}
+function assertPatchPathsAreDeliveryEligible(patch) {
+  for (const line of patch.split("\n")) {
+    let paths = [];
+    if (line.startsWith("diff --git ")) {
+      const parsed = parseDiffGitHeaderPaths(line);
+      if (!parsed) {
+        throw new Error(
+          "completion-mode=branch: could not validate a diff header path. Refusing an unscoped patch."
+        );
+      }
+      paths = [parsed.aPath, parsed.bPath];
+    } else if (line.startsWith("--- ") || line.startsWith("+++ ")) {
+      const parsed = parseUnifiedDiffPathLine(line);
+      if (parsed && parsed !== "/dev/null") paths = [parsed];
+    }
+    for (const path2 of paths) {
+      const normalized = path2.replace(/\\/g, "/");
+      if (posix.isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../") || normalized.includes("/../")) {
+        throw new Error(
+          `completion-mode=branch: accepted artifact contains unsafe path ${path2}. Refusing to apply bytes outside the repository.`
+        );
+      }
+      if (shouldExcludeFile(path2)) {
+        throw new Error(
+          `completion-mode=branch: accepted artifact contains excluded path ${path2}. Refusing to apply bytes outside the delivery-eligible artifact.`
+        );
+      }
+    }
+  }
+}
+function rollbackFailedApply(projectRoot, baseSha, patch) {
+  try {
+    execFileSync("git", ["reset", "--hard", baseSha], {
+      cwd: projectRoot,
+      encoding: "utf8"
+    });
+    const addedPaths = parseAddedFilePathsFromPatch(patch);
+    if (addedPaths.length > 0) {
+      const literalPathspecs = addedPaths.map((path2) => `:(literal)${path2}`);
+      execFileSync("git", ["clean", "-d", "-f", "--", ...literalPathspecs], {
+        cwd: projectRoot,
+        encoding: "utf8"
+      });
+    }
+  } catch (rollbackErr) {
+    const rollbackMsg = rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr);
+    throw new Error(
+      `Error: failed to roll back working tree after a failed apply: ${rollbackMsg}. The working tree may be in a partial state. Recover manually with: git reset --hard ${baseSha} && git clean -d -f`
+    );
+  }
+}
+async function verifyAppliedBranch(projectRoot, changedFiles, timeoutMinutes) {
+  const scope = resolveVerificationChannelScope(projectRoot, changedFiles);
+  const channels = [
+    ["build", scope.build],
+    ["lint", scope.lint],
+    ["test", scope.test]
+  ];
+  const unavailableChannel = channels.find(([, channel]) => channel.availability === "unavailable");
+  if (unavailableChannel) {
+    return {
+      status: "unavailable",
+      reason: `Capability-resolved ${unavailableChannel[0]} verification is unavailable for the applied files.`
+    };
+  }
+  const selected = channels.flatMap(
+    ([channel, resolved]) => resolved.availability === "relevant" ? resolved.commands.map((command) => ({ channel, command })) : []
+  );
+  if (selected.length === 0) {
+    return changedFilesRequireVerification(changedFiles) ? {
+      status: "unavailable",
+      reason: "No capability-resolved verification command covers the applied source files."
+    } : {
+      status: "not_run",
+      reason: "The applied files have no applicable deterministic verification command."
+    };
+  }
+  const outcomes = [];
+  for (const { channel, command } of selected) {
+    const startedAt = Date.now();
+    const result = await runVerificationCommand(command, {
+      cwd: projectRoot,
+      timeoutMs: timeoutMinutes !== void 0 ? timeoutMinutes * 6e4 : DEFAULT_TIMEOUT_MS
+    });
+    outcomes.push({
+      ...classifyResolverCommand(command, result, Date.now() - startedAt),
+      channel
+    });
+  }
+  const aggregate = aggregateResolverOutcomes(outcomes);
+  const commandEvidence = outcomes.map(({ channel, command, classification, durationMs }) => ({
+    channel,
+    command,
+    classification,
+    durationMs
+  }));
+  if (aggregate.classification !== "passed") {
+    return {
+      status: aggregate.classification === "unavailable" ? "unavailable" : "failed",
+      reason: aggregate.representative?.message ?? "Capability-resolved post-apply verification produced no usable evidence.",
+      commands: commandEvidence
+    };
+  }
+  return {
+    status: "passed",
+    reason: `Passed ${outcomes.length} capability-resolved verification command(s).`,
+    commands: commandEvidence
+  };
+}
+async function applyBranch(winner, modeSource, context) {
+  const inCi = context.isCi ?? isCompeteNonInteractiveEnvironment();
+  if (inCi && modeSource !== "flag" && modeSource !== "env") {
+    throw new Error(
+      "completion-mode=branch requires explicit opt-in in CI. Use --completion-mode branch or POETIC_COMPLETION_MODE=branch to enable."
+    );
+  }
+  if (!isWorkingTreeClean(context.projectRoot)) {
+    throw new Error(
+      "completion-mode=branch requires a clean working tree. Commit or stash your changes first."
+    );
+  }
+  if (!inCi && !hasBranchModeAck(context.projectRoot)) {
+    if (process.stdout.isTTY) {
+      const readline = await import("readline");
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const answer = await new Promise((resolve) => {
+        rl.question(
+          "completion-mode=branch will apply changes directly to your current branch.\nThis is a one-time confirmation per repo. Continue? [y/N] ",
+          (ans) => {
+            rl.close();
+            resolve(ans.trim().toLowerCase());
+          }
+        );
+      });
+      if (answer !== "y" && answer !== "yes") {
+        console.log("Aborted.");
+        throw new CompletionModeCancelledError("branch", winner.variantId);
+      }
+      writeBranchModeAck(context.projectRoot);
+    }
+  }
+  console.log(`Applying ${winner.variantId} changes to current branch...`);
+  const baseSha = execFileSync("git", ["rev-parse", "HEAD"], {
+    cwd: context.projectRoot,
+    encoding: "utf8"
+  }).trim();
+  const baselineRef = winner.baselineRef?.trim();
+  if (!baselineRef) {
+    throw new Error(
+      `completion-mode=branch: winner ${winner.variantId} is missing a trustworthy baselineRef. Refusing to apply without proving the target branch is still at the competition base.`
+    );
+  }
+  const normalizedBaseline = baselineRef.toLowerCase();
+  const normalizedHead = baseSha.toLowerCase();
+  const baselineMatchesHead = normalizedBaseline === normalizedHead || normalizedBaseline.length >= 7 && normalizedHead.startsWith(normalizedBaseline) || normalizedHead.length >= 7 && normalizedBaseline.startsWith(normalizedHead);
+  if (!baselineMatchesHead) {
+    throw new Error(
+      `completion-mode=branch: target HEAD moved since the competition started (expected ${baselineRef}, found ${baseSha}). Refusing to reverse or overwrite concurrent commits.`
+    );
+  }
+  const targetBranch = readGitBranch(context.projectRoot);
+  const sourceBranch = resolveWinnerBranchName(winner);
+  const sourceHeadSha = readWinnerHead(winner, context.projectRoot);
+  let applyAttempted = false;
+  let releaseCheckoutMutationLock;
+  let patchOutput = "";
+  let appliedEvent;
+  try {
+    let source = "none";
+    let artifactDiff;
+    if (winner.worktreePath) {
+      let intentIndex;
+      try {
+        intentIndex = await prepareUntrackedIntentIndex({
+          worktreePath: winner.worktreePath
+        });
+      } catch (prepareErr) {
+        if (existsSync(winner.worktreePath)) {
+          const prepareMsg = prepareErr instanceof Error ? prepareErr.message : String(prepareErr);
+          throw new Error(
+            `completion-mode=branch: failed to stage untracked winner files for the diff from worktree ${winner.worktreePath}: ${prepareMsg}. Refusing to apply a patch that would silently omit newly created files.`
+          );
+        }
+      }
+      try {
+        patchOutput = execFileSync(
+          "git",
+          ["diff", ...COMPETE_DIFF_BINARY_FLAGS, "--no-color", baseSha],
+          {
+            cwd: winner.worktreePath,
+            encoding: "utf8",
+            maxBuffer: COMPETE_DIFF_MAX_BUFFER_BYTES,
+            // Read against the temp index so untracked files render as new-file
+            // blocks. Omitted when there were none, keeping the no-untracked-work
+            // case byte-identical to previous behavior.
+            ...intentIndex?.indexPath ? { env: { ...process.env, GIT_INDEX_FILE: intentIndex.indexPath } } : {}
+          }
+        );
+        source = "worktree";
+      } catch (diffErr) {
+        const worktreeMissing = !existsSync(winner.worktreePath);
+        if (!worktreeMissing) {
+          const diffMsg = diffErr instanceof Error ? diffErr.message : String(diffErr);
+          throw new Error(
+            `completion-mode=branch: failed to read the winner diff from worktree ${winner.worktreePath}: ${diffMsg}. Refusing to fall back to a possibly-stale cached diff because the worktree is present but the diff could not be read.`
+          );
+        }
+      } finally {
+        await intentIndex?.dispose();
+      }
+    }
+    let acceptedDiff;
+    if (winner.worktreeDiff && isRecoverableCompetitionDiff(winner.worktreeDiff)) {
+      acceptedDiff = winner.worktreeDiff;
+    } else if (winner.artifactManifest) {
+      artifactDiff = await readArtifactDiffFromManifestPath(winner.artifactManifest, context.projectRoot) ?? void 0;
+      if (artifactDiff && artifactDiff.trim().length > 0) {
+        acceptedDiff = artifactDiff;
+      }
+    }
+    const legacyByteIdentity = source === "worktree" && acceptedDiff !== void 0 && normalizePatchForGitApply(patchOutput) === normalizePatchForGitApply(acceptedDiff);
+    if (acceptedDiff) {
+      assertPatchPathsAreDeliveryEligible(acceptedDiff);
+      if (source !== "worktree") patchOutput = acceptedDiff;
+    }
+    if (source === "worktree" && patchOutput.trim() && !winner.acceptedWorkspaceTreeSha && !legacyByteIdentity) {
+      throw new Error(
+        acceptedDiff ? "completion-mode=branch: live winner diff is not byte-identical to the accepted eligible artifact and has no accepted workspace-tree identity. Refusing stale or expanded application." : "completion-mode=branch: live winner has no accepted cached or persisted artifact identity (workspace-tree identity unavailable). Refusing to apply an unverified live worktree state."
+      );
+    }
+    if (source === "none" && winner.worktreeDiff && isRecoverableCompetitionDiff(winner.worktreeDiff)) {
+      patchOutput = winner.worktreeDiff;
+      source = "cached-diff";
+    }
+    if (source === "none" && winner.artifactManifest) {
+      artifactDiff ??= await readArtifactDiffFromManifestPath(winner.artifactManifest, context.projectRoot) ?? void 0;
+      if (artifactDiff && artifactDiff.trim().length > 0) {
+        patchOutput = artifactDiff;
+        source = "artifact";
+      }
+    }
+    if (source === "none") {
+      throw new Error(
+        `completion-mode=branch: winner ${winner.variantId} has no worktree path, cached diff, or artifact diff for application.`
+      );
+    }
+    assertPatchPathsAreDeliveryEligible(patchOutput);
+    if (!patchOutput.trim()) {
+      console.log("Winner has no changes relative to HEAD \u2014 nothing to apply.");
+      context.onApplied?.({
+        mode: "branch",
+        variantId: winner.variantId,
+        taskId: context.taskId,
+        appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sourceBranch,
+        sourceHeadSha,
+        targetBranch,
+        targetPreApplyHeadSha: baseSha,
+        targetPostApplyHeadSha: baseSha,
+        diffSource: source,
+        changedFiles: [],
+        filesChanged: 0,
+        reason: "empty_diff"
+      });
+      return;
+    }
+    patchOutput = normalizePatchForGitApply(patchOutput);
+    if (source === "worktree") {
+      await assertLiveWorkspaceMatchesAcceptedArtifact(winner, "branch");
+    }
+    releaseCheckoutMutationLock = await acquireCheckoutMutationLock(context.projectRoot);
+    await releaseCheckoutMutationLock.assertOwned();
+    if (!isWorkingTreeClean(context.projectRoot)) {
+      throw new Error(
+        "completion-mode=branch: target working tree changed while resolving the winner patch. Refusing to mix concurrent edits into the apply transaction."
+      );
+    }
+    const currentTargetHead = readGitHead(context.projectRoot);
+    if (currentTargetHead !== baseSha) {
+      throw new Error(
+        `completion-mode=branch: target HEAD changed while resolving the winner patch (${baseSha} -> ${currentTargetHead ?? "unavailable"}). Refusing stale application.`
+      );
+    }
+    await releaseCheckoutMutationLock.assertOwned();
+    applyAttempted = true;
+    execFileSync("git", ["apply", "--3way", ...COMPETE_GIT_APPLY_WHITESPACE_FLAGS], {
+      cwd: context.projectRoot,
+      input: patchOutput,
+      encoding: "utf8"
+    });
+    await releaseCheckoutMutationLock.assertOwned();
+    const targetPostApplyHeadSha = readGitHead(context.projectRoot);
+    const changedFiles = parsePorcelainChangedFiles(
+      execFileSync("git", ["status", "--porcelain"], {
+        cwd: context.projectRoot,
+        encoding: "utf8"
+      })
+    );
+    console.log(
+      source === "cached-diff" ? `Applied ${winner.variantId} changes to current branch (from cached diff).` : source === "artifact" ? `Applied ${winner.variantId} changes to current branch (from artifact diff).` : `Applied ${winner.variantId} changes to current branch.`
+    );
+    appliedEvent = {
+      mode: "branch",
+      variantId: winner.variantId,
+      taskId: context.taskId,
+      appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sourceBranch,
+      sourceHeadSha,
+      targetBranch,
+      targetPreApplyHeadSha: baseSha,
+      targetPostApplyHeadSha,
+      diffSource: source,
+      changedFiles,
+      filesChanged: changedFiles.length
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`Error: failed to apply changes: ${msg}`);
+    if (applyAttempted) {
+      try {
+        if (releaseCheckoutMutationLock) {
+          await releaseCheckoutMutationLock.assertOwned();
+        }
+        rollbackFailedApply(context.projectRoot, baseSha, patchOutput);
+        console.log(`Info: rolled back working tree to ${baseSha} after failed apply.`);
+      } catch (rollbackErr) {
+        const rollbackMsg = rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr);
+        console.error(
+          rollbackErr instanceof FileLockCompromisedError ? `Warning: checkout lock ownership was lost; rollback was skipped and the target tree may be partially applied at ${context.projectRoot}. ${rollbackMsg}` : rollbackMsg
+        );
+      }
+    }
+    throw err;
+  } finally {
+    if (releaseCheckoutMutationLock) {
+      await releaseCheckoutMutationLock().catch(() => void 0);
+      releaseCheckoutMutationLock = void 0;
+    }
+  }
+  if (!appliedEvent) return;
+  const postApplyVerification = await verifyAppliedBranch(
+    context.projectRoot,
+    appliedEvent.changedFiles ?? [],
+    context.resolvedConfig?.timeout
+  );
+  const verifiedEvent = { ...appliedEvent, postApplyVerification };
+  context.onApplied?.(verifiedEvent);
+  if (postApplyVerification.status === "failed" || postApplyVerification.status === "unavailable") {
+    throw new Error(
+      `completion-mode=branch post-apply verification ${postApplyVerification.status}: ${postApplyVerification.reason}. The applied changes were left in the working tree for inspection.`
+    );
+  }
+}
+function isOffScopeRepairOverrideEnabled(context) {
+  return context.allowOffScopeRepair === true || readEnv(POETIC_ALLOW_OFF_SCOPE_REPAIR).value === true;
+}
+function assertRepairArtifactAllowedForMode(winner, effectiveMode, context) {
+  const classification = winner.repairOutcome?.classification;
+  const policy = resolveRepairArtifactPolicy({
+    classification,
+    effectiveMode,
+    allowOffScopeRepair: isOffScopeRepairOverrideEnabled(context)
+  });
+  if (winner.repairOutcome) {
+    winner.repairOutcome.finalArtifactTrust = policy.finalArtifactTrust;
+  }
+  if (policy.action === "block") {
+    throw new Error(
+      `${policy.reason}. Judge verdict does not apply to the repaired final artifact. Use --allow-off-scope-repair or POETIC_ALLOW_OFF_SCOPE_REPAIR=1 to override.`
+    );
+  }
+  if (policy.action === "warn") {
+    if (classification === "off_scope") {
+      console.warn(
+        `Warning: ${policy.reason}. Judge verdict does not apply to the repaired final artifact.`
+      );
+    } else if (classification === "scope_expanded" || classification === "substantive_in_scope") {
+      console.warn(
+        `Warning: ${policy.reason}. Judge verdict only partially applies to the repaired final artifact.`
+      );
+    } else if (classification === "unknown") {
+      console.warn(`Warning: ${policy.reason}.`);
+    }
+  }
+}
+async function applyCompletionMode(winner, mode, modeSource, context) {
+  let preCreatePrDowngrade = mode === "none" ? "isolated" : mode;
+  if (mode === "auto") {
+    preCreatePrDowngrade = context.autoModePreference ?? "isolated";
+  }
+  const effectiveMode = resolveEffectiveCompletionMode(mode, {
+    ...context,
+    winner: {
+      executionMode: winner.executionMode
+    }
+  });
+  if (context.createPr === false && preCreatePrDowngrade === "pr") {
+    console.log("completion-mode=pr downgraded to isolated (--no-create-pr)");
+  }
+  assertRepairArtifactAllowedForMode(winner, effectiveMode, context);
+  if ((effectiveMode === "pr" || effectiveMode === "branch") && winner.gatesPassed !== true) {
+    throw new Error(
+      `Refusing completion-mode=${effectiveMode}: apply gates did not pass for ${winner.variantId}`
+    );
+  }
+  switch (effectiveMode) {
+    case "isolated":
+      await applyIsolated(winner, context);
+      break;
+    case "pr":
+      await applyPr(winner, context);
+      break;
+    case "branch":
+      await applyBranch(winner, modeSource, context);
+      break;
+    default:
+      console.warn(
+        `Unknown completion mode: ${effectiveMode}; falling back to isolated.`
+      );
+      await applyIsolated(winner, context);
+  }
+}
+
+export {
+  acquireCheckoutMutationLock,
+  prepareUntrackedIntentIndex,
+  COMPETE_DIFF_BINARY_FLAGS,
+  COMPETE_GIT_APPLY_WHITESPACE_FLAGS,
+  COMPETE_DIFF_MAX_BUFFER_BYTES,
+  isRecoverableCompetitionDiff,
+  PR_REMOTE_OP_TIMEOUT_MS,
+  resolveEffectiveCompletionMode,
+  CompletionModeCancelledError,
+  applyCompletionMode
+};
+//# sourceMappingURL=chunk-BDATUDDJ.js.map