xab 1.0.0 → 2.0.0

package/dist/index.js

@@ -0,0 +1,2638 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/config.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+function loadConfig(repoPath, explicitPath) {
+  const paths = explicitPath ? [explicitPath] : CONFIG_FILENAMES.map((f) => join(repoPath, f));
+  for (const p of paths) {
+    if (existsSync(p)) {
+      try {
+        const raw = readFileSync(p, "utf-8");
+        const parsed = JSON.parse(raw);
+        return { ...DEFAULT_CONFIG, ...parsed };
+      } catch (e) {
+        throw new Error(`Failed to parse config at ${p}: ${e.message}`);
+      }
+    }
+  }
+  return { ...DEFAULT_CONFIG };
+}
+var CONFIG_FILENAMES, DEFAULT_CONFIG;
+var init_config = __esm(() => {
+  CONFIG_FILENAMES = [".backmerge.json", ".backmerge/config.json", "backmerge.config.json"];
+  DEFAULT_CONFIG = {
+    instructionFiles: [],
+    docRoutes: [],
+    promptHints: [],
+    pathRemaps: [],
+    reviewStrictness: "normal",
+    maxAttempts: 2,
+    commitPrefix: "backmerge:"
+  };
+});
+
+// src/context.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync } from "fs";
+import { join as join2, relative } from "path";
+function minimatch(path, pattern) {
+  let re = pattern;
+  re = re.replace(/\*\*\//g, "\x00GS\x00");
+  re = re.replace(/\*\*/g, "\x00GA\x00");
+  re = re.replace(/\*/g, "\x00S\x00");
+  re = re.replace(/\?/g, "\x00Q\x00");
+  re = re.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  re = re.replace(/\0GS\0/g, "(?:.*/)?");
+  re = re.replace(/\0GA\0/g, ".*");
+  re = re.replace(/\0S\0/g, "[^/]*");
+  re = re.replace(/\0Q\0/g, "[^/]");
+  return new RegExp(`^${re}$`).test(path);
+}
+function inferRepoStructure(repoPath) {
+  const entries = readdirSync(repoPath, { withFileTypes: true });
+  const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
+  const files = entries.filter((e) => e.isFile()).map((e) => e.name);
+  const configFiles = files.filter((f) => [
+    "package.json",
+    "tsconfig.json",
+    "Cargo.toml",
+    "go.mod",
+    "pyproject.toml",
+    "pnpm-workspace.yaml",
+    "turbo.json",
+    "nx.json",
+    "lerna.json",
+    "bun.lockb",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "Makefile",
+    "foundry.toml",
+    "hardhat.config.ts",
+    "hardhat.config.js"
+  ].includes(f));
+  const monoSignals = ["apps", "packages", "libs", "modules", "services", "crates", "workspace"];
+  const hasMonoDir = dirs.some((d) => monoSignals.includes(d));
+  const hasWorkspaceConfig = ["pnpm-workspace.yaml", "turbo.json", "nx.json", "lerna.json"].some((f) => files.includes(f));
+  let hasWorkspacesField = false;
+  let packageManager;
+  const pkgPath = join2(repoPath, "package.json");
+  if (existsSync2(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+      hasWorkspacesField = Array.isArray(pkg.workspaces) || !!pkg.workspaces?.packages;
+      if (pkg.packageManager)
+        packageManager = pkg.packageManager;
+      else if (existsSync2(join2(repoPath, "bun.lockb")))
+        packageManager = "bun";
+      else if (existsSync2(join2(repoPath, "pnpm-lock.yaml")))
+        packageManager = "pnpm";
+      else if (existsSync2(join2(repoPath, "yarn.lock")))
+        packageManager = "yarn";
+    } catch {}
+  }
+  const componentDirs = dirs.filter((d) => {
+    const sub = join2(repoPath, d);
+    return existsSync2(join2(sub, "package.json")) || existsSync2(join2(sub, "go.mod")) || existsSync2(join2(sub, "Cargo.toml"));
+  });
+  const isComponentMonorepo = componentDirs.length >= 2;
+  const isMonorepo = hasMonoDir || hasWorkspaceConfig || hasWorkspacesField || isComponentMonorepo;
+  let apps;
+  let packages;
+  if (isMonorepo) {
+    for (const subdir of ["apps", "services"]) {
+      const p = join2(repoPath, subdir);
+      if (existsSync2(p)) {
+        apps = readdirSync(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => `${subdir}/${e.name}`);
+      }
+    }
+    for (const subdir of ["packages", "libs", "modules"]) {
+      const p = join2(repoPath, subdir);
+      if (existsSync2(p)) {
+        packages = readdirSync(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => `${subdir}/${e.name}`);
+      }
+    }
+    if (!apps && componentDirs.length >= 2) {
+      apps = componentDirs;
+    }
+  }
+  return {
+    type: isMonorepo ? "monorepo" : "single-project",
+    topLevelDirs: dirs,
+    apps,
+    packages,
+    configFiles,
+    packageManager
+  };
+}
+function discoverInstructionFiles(repoPath, config) {
+  const found = new Map;
+  for (const candidate of INSTRUCTION_FILE_CANDIDATES) {
+    const full = join2(repoPath, candidate);
+    if (existsSync2(full)) {
+      try {
+        const content = readFileSync2(full, "utf-8");
+        found.set(candidate, content.slice(0, 8000));
+      } catch {}
+    }
+  }
+  for (const f of config.instructionFiles ?? []) {
+    if (found.has(f))
+      continue;
+    const full = join2(repoPath, f);
+    if (existsSync2(full)) {
+      try {
+        found.set(f, readFileSync2(full, "utf-8").slice(0, 8000));
+      } catch {}
+    }
+  }
+  return found;
+}
+function discoverDocPaths(repoPath) {
+  const paths = [];
+  function walk(dir, globs) {
+    if (!existsSync2(dir))
+      return;
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join2(dir, entry.name);
+      const rel = relative(repoPath, full);
+      if (entry.isDirectory()) {
+        walk(full, globs);
+      } else if (entry.isFile() && globs.some((g) => minimatch(rel, g))) {
+        paths.push(rel);
+      }
+    }
+  }
+  for (const glob of DOC_DIR_GLOBS) {
+    const baseDir = glob.split("/")[0];
+    walk(join2(repoPath, baseDir), [glob]);
+  }
+  try {
+    for (const entry of readdirSync(repoPath, { withFileTypes: true })) {
+      if (entry.isDirectory() && !entry.name.startsWith(".")) {
+        const readme = join2(repoPath, entry.name, "README.md");
+        if (existsSync2(readme)) {
+          paths.push(`${entry.name}/README.md`);
+        }
+      }
+    }
+  } catch {}
+  return [...new Set(paths)].sort();
+}
+function buildRepoContext(repoPath, config) {
+  const structure = inferRepoStructure(repoPath);
+  const instructions = discoverInstructionFiles(repoPath, config);
+  const docPaths = discoverDocPaths(repoPath);
+  return { structure, instructions, docPaths };
+}
+function buildCommitContext(repoPath, repoCtx, config, touchedPaths, commitMessage) {
+  const includedFiles = [];
+  const sections = [];
+  const rs = repoCtx.structure;
+  const structLines = [`Repository: ${rs.type}`];
+  if (rs.packageManager)
+    structLines.push(`Package manager: ${rs.packageManager}`);
+  if (rs.apps?.length)
+    structLines.push(`Components: ${rs.apps.join(", ")}`);
+  if (rs.packages?.length)
+    structLines.push(`Packages: ${rs.packages.join(", ")}`);
+  sections.push(structLines.join(`
+`));
+  for (const [name, content] of repoCtx.instructions) {
+    sections.push(`--- ${name} ---
+${content}`);
+    includedFiles.push(name);
+  }
+  if (config.promptHints?.length) {
+    sections.push(`--- Merge hints ---
+${config.promptHints.join(`
+`)}`);
+  }
+  if (config.pathRemaps?.length) {
+    const lines = config.pathRemaps.map((r) => `  ${r.source} \u2192 ${r.target}${r.note ? ` (${r.note})` : ""}`);
+    sections.push(`--- Path remaps ---
+${lines.join(`
+`)}`);
+  }
+  const matchedDocs = new Set;
+  for (const route of config.docRoutes ?? []) {
+    if (routeMatches(route, touchedPaths, commitMessage)) {
+      for (const docGlob of route.docs) {
+        for (const docPath of repoCtx.docPaths) {
+          if (minimatch(docPath, docGlob)) {
+            matchedDocs.add(docPath);
+          }
+        }
+      }
+    }
+  }
+  const touchedTopDirs = new Set(touchedPaths.map((p) => p.split("/")[0]).filter(Boolean));
+  for (const docPath of repoCtx.docPaths) {
+    const docName = docPath.toLowerCase();
+    for (const dir of touchedTopDirs) {
+      if (docName.includes(dir.toLowerCase())) {
+        matchedDocs.add(docPath);
+      }
+    }
+    const msgLower = commitMessage.toLowerCase();
+    const docBasename = docPath.split("/").pop()?.replace(/\.md$/, "").toLowerCase() ?? "";
+    if (docBasename && msgLower.includes(docBasename)) {
+      matchedDocs.add(docPath);
+    }
+  }
+  let docBudget = 4000;
+  for (const docPath of matchedDocs) {
+    if (docBudget <= 0)
+      break;
+    const full = join2(repoPath, docPath);
+    if (existsSync2(full)) {
+      try {
+        const content = readFileSync2(full, "utf-8");
+        const chunk = content.slice(0, Math.min(2000, docBudget));
+        sections.push(`--- ${docPath} ---
+${chunk}`);
+        includedFiles.push(docPath);
+        docBudget -= chunk.length;
+      } catch {}
+    }
+  }
+  return {
+    promptBlock: sections.join(`
+
+`),
+    includedFiles
+  };
+}
+function routeMatches(route, touchedPaths, commitMessage) {
+  for (const glob of route.pathGlobs) {
+    for (const path of touchedPaths) {
+      if (minimatch(path, glob))
+        return true;
+    }
+  }
+  if (route.keywords) {
+    const msgLower = commitMessage.toLowerCase();
+    for (const kw of route.keywords) {
+      if (msgLower.includes(kw.toLowerCase()))
+        return true;
+    }
+  }
+  return false;
+}
+var INSTRUCTION_FILE_CANDIDATES, DOC_DIR_GLOBS;
+var init_context = __esm(() => {
+  INSTRUCTION_FILE_CANDIDATES = [
+    "AGENTS.md",
+    "CLAUDE.md",
+    "CONTRIBUTING.md",
+    ".cursorrules",
+    ".github/copilot-instructions.md"
+  ];
+  DOC_DIR_GLOBS = ["ai-docs/**/*.md", "docs/**/*.md", ".backmerge/docs/**/*.md"];
+});
+
+// src/decisions.ts
+function validateDecision(d, headBefore, headAfter, isDryRun) {
+  const errors = [];
+  const headMoved = headBefore !== headAfter;
+  if (isDryRun) {
+    if (d.kind === "applied") {
+      errors.push("Dry-run produced 'applied' decision \u2014 must use 'would_apply'");
+    }
+    if (headMoved) {
+      errors.push(`Dry-run moved HEAD from ${headBefore.slice(0, 8)} to ${headAfter.slice(0, 8)}`);
+    }
+  }
+  switch (d.kind) {
+    case "applied":
+      if (!headMoved)
+        errors.push("Decision is 'applied' but HEAD did not move");
+      if (!d.newCommitHash)
+        errors.push("Decision is 'applied' but no newCommitHash");
+      break;
+    case "would_apply":
+      if (headMoved)
+        errors.push("Decision is 'would_apply' but HEAD moved");
+      if (!isDryRun)
+        errors.push("'would_apply' only valid in dry-run mode");
+      break;
+    case "already_applied":
+    case "skip":
+      if (headMoved)
+        errors.push(`Decision is '${d.kind}' but HEAD moved`);
+      break;
+    case "failed":
+      if (headMoved)
+        errors.push("Decision is 'failed' but HEAD moved (should have been reset)");
+      break;
+  }
+  return errors;
+}
+function emptyRunSummary() {
+  return { applied: 0, wouldApply: 0, alreadyApplied: 0, skipped: 0, failed: 0, total: 0, cherrySkipped: 0 };
+}
+function updateSummary(s, d) {
+  switch (d.kind) {
+    case "applied":
+      s.applied++;
+      break;
+    case "would_apply":
+      s.wouldApply++;
+      break;
+    case "already_applied":
+      s.alreadyApplied++;
+      break;
+    case "skip":
+      s.skipped++;
+      break;
+    case "failed":
+      s.failed++;
+      break;
+  }
+}
+
+// src/codex.ts
+import { Codex } from "@openai/codex-sdk";
+import { execSync } from "child_process";
+function checkCodexInstalled() {
+  try {
+    execSync("codex --version", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function splitDiff(diff) {
+  if (diff.length <= CHUNK_SIZE)
+    return [diff];
+  const chunks = [];
+  const statEnd = diff.indexOf(`
+
+`);
+  const firstEnd = statEnd > 0 ? Math.max(statEnd, CHUNK_SIZE) : CHUNK_SIZE;
+  chunks.push(diff.slice(0, Math.min(firstEnd, diff.length)));
+  let pos = chunks[0].length;
+  while (pos < diff.length) {
+    let end = pos + CHUNK_SIZE;
+    if (end < diff.length) {
+      const boundary = diff.lastIndexOf(`
+diff --git `, end);
+      if (boundary > pos)
+        end = boundary;
+    }
+    chunks.push(diff.slice(pos, Math.min(end, diff.length)));
+    pos = end;
+  }
+  return chunks;
+}
+function truncateDiff(diff, maxLen) {
+  if (diff.length <= maxLen)
+    return diff;
+  const statEnd = diff.indexOf(`
+
+`);
+  if (statEnd === -1 || statEnd > maxLen)
+    return diff.slice(0, maxLen) + `
+
+... [truncated]`;
+  const stat = diff.slice(0, statEnd);
+  const remaining = maxLen - stat.length - 50;
+  if (remaining <= 0)
+    return stat + `
+
+... [patch truncated]`;
+  return stat + diff.slice(statEnd, statEnd + remaining) + `
+
+... [patch truncated]`;
+}
+function parseJson(raw, fallback) {
+  try {
+    return JSON.parse(raw);
+  } catch {}
+  const m = raw.match(/\{[\s\S]*\}/);
+  if (m) {
+    try {
+      return JSON.parse(m[0]);
+    } catch {}
+  }
+  return fallback;
+}
+async function analyzeCommit(opts) {
+  const codex = new Codex;
+  const thread = codex.startThread({
+    workingDirectory: opts.worktreePath,
+    sandboxMode: "read-only",
+    model: "gpt-5.4",
+    modelReasoningEffort: "high"
+  });
+  const diffChunks = splitDiff(opts.commitDiff);
+  const firstPrompt = `${MERGE_PREAMBLE}
+${opts.repoContext ? `## Repository context
+${opts.repoContext}
+` : ""}
+## Source commit (from "${opts.sourceBranch}")
+Hash: ${opts.commitHash}
+Message: ${opts.commitMessage}
+
+### Diff${diffChunks.length > 1 ? ` (part 1/${diffChunks.length})` : ""}:
+\`\`\`diff
+${diffChunks[0]}
+\`\`\`
+
+## Latest state of source branch (for context):
+\`\`\`diff
+${truncateDiff(opts.sourceLatestDiff, 1e4)}
+\`\`\`
+
+${diffChunks.length > 1 ? "I will send the remaining diff parts next. Read them all before analyzing." : ""}
+
+## Your task
+You are looking at a worktree based on the TARGET branch "${opts.targetBranch}".
+
+1. Read the target worktree files affected by this commit
+2. Summarize what the source commit does
+3. Determine if the target already has this functionality:
+   - "yes" = exact same functionality exists (check every affected file)
+   - "partial" = some parts exist
+   - "no" = missing
+4. If not fully present, describe a step-by-step strategy for applying cleanly
+5. List which top-level components/directories are affected
+6. Consider: does this change make sense for the target? Is it useful?`;
+  let turn;
+  if (diffChunks.length > 1) {
+    await thread.run(firstPrompt);
+    for (let i = 1;i < diffChunks.length - 1; i++) {
+      await thread.run(`### Diff (part ${i + 1}/${diffChunks.length}):
+\`\`\`diff
+${diffChunks[i]}
+\`\`\`
+
+Continue reading. More parts coming.`);
+    }
+    const lastIdx = diffChunks.length - 1;
+    turn = await thread.run(`### Diff (part ${lastIdx + 1}/${diffChunks.length} \u2014 final):
+\`\`\`diff
+${diffChunks[lastIdx]}
+\`\`\`
+
+You now have the complete diff. Analyze and produce your structured response.`, { outputSchema: analysisSchema });
+  } else {
+    turn = await thread.run(firstPrompt, { outputSchema: analysisSchema });
+  }
+  return parseJson(turn.finalResponse, {
+    summary: turn.finalResponse.slice(0, 500),
+    alreadyInTarget: "no",
+    reasoning: "Could not parse structured output",
+    applicationStrategy: "Manual review recommended",
+    affectedComponents: []
+  });
+}
+async function applyCommit(opts) {
+  const codex = new Codex;
+  const thread = codex.startThread({
+    workingDirectory: opts.worktreePath,
+    sandboxMode: "workspace-write",
+    model: "gpt-5.4",
+    modelReasoningEffort: "high"
+  });
+  const commitMsg = `${opts.commitPrefix} ${opts.commitMessage} (from ${opts.commitHash.slice(0, 8)})`;
+  const diffChunks = splitDiff(opts.commitDiff);
+  const instructions = `## Application strategy:
+${opts.applicationStrategy}
+
+## Instructions \u2014 clean curated merge
+- Read the affected files in the worktree FIRST to understand the target's current state
+- Apply changes so the result is clean, compiling, and conflict-free
+- Adapt to the target's code style, imports, and architecture
+- If the target already has a different version of the same logic, merge both intents
+- Preserve the target's existing improvements \u2014 do not regress
+- Create or modify files as needed; delete files if the source commit deleted them
+- After applying, run exactly: git add -A && git commit -m "${commitMsg.replace(/"/g, "\\\"")}"
+- You MUST create exactly ONE commit. Not zero, not two.
+- No conflict markers, dead code, or TODO placeholders
+- If impossible to apply cleanly, explain why in notes
+
+Report what you did.`;
+  const firstPrompt = `${MERGE_PREAMBLE}
+${opts.repoContext ? `## Repository context
+${opts.repoContext}
+` : ""}
+## Source commit (from "${opts.sourceBranch}")
+Hash: ${opts.commitHash}
+Message: ${opts.commitMessage}
+
+### Diff${diffChunks.length > 1 ? ` (part 1/${diffChunks.length})` : ""}:
+\`\`\`diff
+${diffChunks[0]}
+\`\`\`
+
+${diffChunks.length > 1 ? "I will send the remaining diff parts next. Read them all before applying." : instructions}`;
+  let turn;
+  if (diffChunks.length > 1) {
+    await thread.run(firstPrompt);
+    for (let i = 1;i < diffChunks.length - 1; i++) {
+      await thread.run(`### Diff (part ${i + 1}/${diffChunks.length}):
+\`\`\`diff
+${diffChunks[i]}
+\`\`\`
+
+Continue reading. More parts coming.`);
+    }
+    const lastIdx = diffChunks.length - 1;
+    turn = await thread.run(`### Diff (part ${lastIdx + 1}/${diffChunks.length} \u2014 final):
+\`\`\`diff
+${diffChunks[lastIdx]}
+\`\`\`
+
+You now have the complete diff.
+
+${instructions}`, { outputSchema: applyResultSchema });
+  } else {
+    turn = await thread.run(firstPrompt, { outputSchema: applyResultSchema });
+  }
+  return parseJson(turn.finalResponse, {
+    applied: false,
+    filesChanged: [],
+    commitMessage: commitMsg,
+    notes: turn.finalResponse.slice(0, 1000),
+    adaptations: ""
+  });
+}
+async function fixFromReview(opts) {
+  const codex = new Codex;
+  const thread = codex.startThread({
+    workingDirectory: opts.worktreePath,
+    sandboxMode: "workspace-write",
+    model: "gpt-5.4",
+    modelReasoningEffort: "high"
+  });
+  const commitMsg = `${opts.commitPrefix} ${opts.commitMessage} (from ${opts.commitHash.slice(0, 8)})`;
+  const prompt = `A code reviewer found issues with your previous apply of commit ${opts.commitHash.slice(0, 8)} ("${opts.commitMessage}").
+
+${opts.repoContext ? `## Repository context
+${opts.repoContext}
+` : ""}
+
+## Review objections \u2014 you MUST fix ALL of these:
+${opts.reviewIssues.map((issue, i) => `${i + 1}. ${issue}`).join(`
+`)}
+
+## Instructions
+- Read the affected files to understand the current state
+- Fix every issue the reviewer raised
+- Do NOT introduce new problems while fixing
+- After fixing, amend the commit: git add -A && git commit --amend -m "${commitMsg.replace(/"/g, "\\\"")}"
+- The result must be a single clean commit with no issues
+
+Report what you fixed.`;
+  const turn = await thread.run(prompt, { outputSchema: applyResultSchema });
+  return parseJson(turn.finalResponse, {
+    applied: false,
+    filesChanged: [],
+    commitMessage: commitMsg,
+    notes: turn.finalResponse.slice(0, 1000),
+    adaptations: ""
+  });
+}
+var analysisSchema, applyResultSchema, CHUNK_SIZE = 24000, MERGE_PREAMBLE = `## Important: this is a CURATED MERGE, not a blind cherry-pick
+
+You are helping merge changes from a source branch into a target branch that may have diverged significantly.
+
+Rules:
+- Preserve the target branch's architecture, conventions, and improvements
+- Merge the INTENT of the source commit, not its literal paths/code
+- The target may have different file locations, naming, or implementations
+- Only apply changes that are genuinely useful to the target
+- Do not regress target-specific improvements or features
+- Prefer adapting behavior into the target's existing code structure
+- If the source commit doesn't make sense for the target, explain why
+`;
+var init_codex = __esm(() => {
+  analysisSchema = {
+    type: "object",
+    properties: {
+      summary: { type: "string", description: "Concise summary of what this commit does" },
+      alreadyInTarget: {
+        type: "string",
+        enum: ["yes", "no", "partial"],
+        description: "Whether the target branch already has this change. 'yes' = exact same functionality exists. 'partial' = some parts exist. 'no' = missing."
+      },
+      reasoning: { type: "string", description: "Evidence \u2014 list which files you checked and what you found" },
+      applicationStrategy: {
+        type: "string",
+        description: "Step-by-step strategy for applying. If already present, say 'skip'."
+      },
+      affectedComponents: {
+        type: "array",
+        items: { type: "string" },
+        description: "Top-level directories/components affected (e.g. 'api', 'frontend', 'contracts')"
+      }
+    },
+    required: ["summary", "alreadyInTarget", "reasoning", "applicationStrategy", "affectedComponents"],
+    additionalProperties: false
+  };
+  applyResultSchema = {
+    type: "object",
+    properties: {
+      applied: { type: "boolean", description: "Whether changes were applied and committed" },
+      filesChanged: { type: "array", items: { type: "string" }, description: "File paths created/modified/deleted" },
+      commitMessage: { type: "string", description: "The commit message used" },
+      notes: { type: "string", description: "Issues encountered or adaptations made" },
+      adaptations: { type: "string", description: "How the changes were adapted to fit the target codebase" }
+    },
+    required: ["applied", "filesChanged", "commitMessage", "notes", "adaptations"],
+    additionalProperties: false
+  };
+});
+
+// src/review.ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+function writeReviewPacket(audit, packet, attempt) {
+  const { commitHash } = packet;
+  audit.writeReviewContext(commitHash, attempt, {
+    commitHash: packet.commitHash,
+    commitMessage: packet.commitMessage,
+    sourceBranch: packet.sourceBranch,
+    targetBranch: packet.targetBranch,
+    analysis: packet.analysis,
+    reviewStrictness: packet.reviewStrictness
+  });
+  if (packet.relevantDocs) {
+    audit.writeRelevantDocs(commitHash, attempt, packet.relevantDocs);
+  }
+  if (packet.appliedDiffStat) {
+    audit.writeDiffStat(commitHash, attempt, packet.appliedDiffStat);
+  }
+  if (packet.appliedDiff) {
+    audit.writeAppliedPatch(commitHash, attempt, packet.appliedDiff);
+  }
+}
+async function reviewAppliedDiff(worktreePath, packet) {
+  const strictnessInstructions = {
+    strict: "Be very strict. Any questionable change should be rejected. Err on the side of caution.",
+    normal: "Be thorough but reasonable. Reject clear issues, accept minor style differences.",
+    lenient: "Focus on correctness and safety. Accept reasonable adaptations even if imperfect."
+  };
+  const prompt = `You are reviewing a curated merge. A commit from "${packet.sourceBranch}" was applied to a branch based on "${packet.targetBranch}".
+
+## Codex analysis of the source commit
+Summary: ${packet.analysis.summary}
+Decision: alreadyInTarget=${packet.analysis.alreadyInTarget}
+Strategy: ${packet.analysis.applicationStrategy}
+Affected components: ${packet.analysis.affectedComponents.join(", ")}
+
+## Source commit
+Hash: ${packet.commitHash}
+Message: ${packet.commitMessage}
+
+## Applied diff (what was actually committed):
+\`\`\`diff
+${packet.appliedDiff.slice(0, 30000)}
+\`\`\`
+
+## Diff stat:
+${packet.appliedDiffStat}
+
+${packet.repoContext ? `## Repository context
+${packet.repoContext}
+` : ""}
+${packet.relevantDocs ? `## Relevant documentation
+${packet.relevantDocs.slice(0, 5000)}
+` : ""}
+
+## Full code review \u2014 think critically
+
+You are not just verifying the diff was applied. You are doing a FULL CODE REVIEW.
+
+### Correctness
+1. Did Codex make the RIGHT decision? Should this commit have been applied at all?
+2. Does the applied change actually achieve the intent of the source commit?
+3. Are there logic errors introduced by adapting the code?
+4. Does the change break any existing target functionality?
+5. Are edge cases handled correctly?
+
+### Cleanliness
+6. NO conflict markers (<<<<<<<, =======, >>>>>>>) anywhere
+7. NO dead code, commented-out old code, or TODO/FIXME placeholders
+8. Imports are correct \u2014 no broken references
+9. Code style matches the target branch's conventions
+10. No duplicate definitions or redundant code
+
+### Architecture
+11. Does the change respect the target's architecture?
+12. Were target-specific improvements preserved (not regressed)?
+13. If the target had a better implementation, was it kept?
+14. Are file paths and module boundaries correct for the target?
+
+### Completeness
+15. The applied changes actually match the stated strategy
+16. Nothing important was missed from the source commit
+17. Files created/deleted as needed
+
+Scope your review to the diff introduced by this commit. Read the affected files in the worktree to understand the full context around the changed lines, but focus your judgment on what this commit changed.
+
+## Strictness: ${packet.reviewStrictness}
+${strictnessInstructions[packet.reviewStrictness]}
+
+If you have ANY objections, be specific about what's wrong and how to fix it. Your issues will be sent back to the apply agent for correction.`;
+  const q = query({
+    prompt,
+    options: {
+      cwd: worktreePath,
+      model: "claude-opus-4-6",
+      maxTurns: 30,
+      permissionMode: "default",
+      outputFormat: reviewSchema,
+      tools: ["Read", "Glob", "Grep", "Bash"],
+      disallowedTools: ["Edit", "Write", "NotebookEdit"],
+      systemPrompt: `You are a senior code reviewer for curated merge operations. Do a full code review \u2014 think about correctness, architecture, and whether the change was the right call.
+
+You can:
+- Read files for full context
+- Search with Glob/Grep
+- Run tests, linters, type-checkers, and build commands via Bash to verify correctness
+- Run any read-only shell command (cat, ls, git diff, git log, etc.)
+
+You MUST NOT modify the worktree in any way. No file writes, no git commits, no destructive commands.
+
+Run relevant tests if you can determine the test command from the repo. Your objections will be sent back to the apply agent for fixing, so be specific and actionable.`
+    }
+  });
+  let resultText = "";
+  for await (const message of q) {
+    if (message.type === "result") {
+      if ("result" in message) {
+        resultText = message.result;
+      }
+      break;
+    }
+  }
+  if (!resultText) {
+    return { approved: false, issues: ["Review produced no output"], summary: "Review failed", confidence: "low" };
+  }
+  try {
+    return JSON.parse(resultText);
+  } catch {
+    const m = resultText.match(/\{[\s\S]*\}/);
+    if (m) {
+      try {
+        return JSON.parse(m[0]);
+      } catch {}
+    }
+    return {
+      approved: false,
+      issues: [`Unparseable review output: ${resultText.slice(0, 200)}`],
+      summary: "Parse error",
+      confidence: "low"
+    };
+  }
+}
+async function verifyReviewIntegrity(wtGit, expectedHead) {
+  const currentHead = (await wtGit.raw(["rev-parse", "HEAD"])).trim();
+  if (currentHead !== expectedHead) {
+    return `Review mutated HEAD: expected ${expectedHead.slice(0, 8)}, got ${currentHead.slice(0, 8)}`;
+  }
+  const status = await wtGit.status();
+  const dirty = status.modified.length + status.created.length + status.deleted.length + status.not_added.length + status.conflicted.length;
+  if (dirty > 0) {
+    const parts = [];
+    if (status.modified.length)
+      parts.push(`${status.modified.length} modified`);
+    if (status.created.length)
+      parts.push(`${status.created.length} staged`);
+    if (status.not_added.length)
+      parts.push(`${status.not_added.length} untracked`);
+    if (status.deleted.length)
+      parts.push(`${status.deleted.length} deleted`);
+    return `Review left dirty worktree: ${parts.join(", ")}`;
+  }
+  return null;
+}
+var reviewSchema;
+var init_review = __esm(() => {
+  reviewSchema = {
+    type: "json_schema",
+    schema: {
+      type: "object",
+      properties: {
+        approved: {
+          type: "boolean",
+          description: "true if changes are clean, correct, and safe. false if issues need fixing."
+        },
+        issues: {
+          type: "array",
+          items: { type: "string" },
+          description: "Specific issues found. Empty if approved."
+        },
+        summary: {
+          type: "string",
+          description: "Brief summary of what was reviewed and the verdict"
+        },
+        confidence: {
+          type: "string",
+          enum: ["high", "medium", "low"],
+          description: "Confidence in the review assessment"
+        }
+      },
+      required: ["approved", "issues", "summary", "confidence"],
+      additionalProperties: false
+    }
+  };
+});
+
+// src/audit.ts
+import { mkdirSync, writeFileSync, appendFileSync, existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
+import { join as join3 } from "path";
+
+class AuditLog {
+  runDir;
+  commitsDir;
+  resultsFile;
+  constructor(baseDir, runId) {
+    this.runDir = join3(baseDir, ".backmerge", "runs", runId);
+    this.commitsDir = join3(this.runDir, "commits");
+    this.resultsFile = join3(this.runDir, "results.jsonl");
+    mkdirSync(this.commitsDir, { recursive: true });
+  }
+  get resultsPath() {
+    return this.resultsFile;
+  }
+  emit(event) {
+    appendFileSync(this.resultsFile, JSON.stringify(event) + `
+`);
+  }
+  commitDir(hash) {
+    const dir = join3(this.commitsDir, hash.slice(0, 8));
+    mkdirSync(dir, { recursive: true });
+    return dir;
+  }
+  attemptDir(hash, attempt) {
+    const dir = join3(this.commitDir(hash), `attempt-${attempt}`);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+  }
+  writeSourcePatch(hash, patch) {
+    const p = join3(this.commitDir(hash), "source.patch");
+    writeFileSync(p, patch);
+    return p;
+  }
+  writeAnalysis(hash, attempt, analysis) {
+    const p = join3(this.attemptDir(hash, attempt), "analysis.json");
+    writeFileSync(p, JSON.stringify(analysis, null, 2));
+    return p;
+  }
+  writeAppliedPatch(hash, attempt, patch) {
+    const p = join3(this.attemptDir(hash, attempt), "applied.patch");
+    writeFileSync(p, patch);
+    return p;
+  }
+  writeReviewContext(hash, attempt, context) {
+    const p = join3(this.attemptDir(hash, attempt), "review-context.json");
+    writeFileSync(p, JSON.stringify(context, null, 2));
+    return p;
+  }
+  writeReviewResult(hash, attempt, result) {
+    const p = join3(this.attemptDir(hash, attempt), "review-result.json");
+    writeFileSync(p, JSON.stringify(result, null, 2));
+    return p;
+  }
+  writeRelevantDocs(hash, attempt, docs) {
+    const p = join3(this.attemptDir(hash, attempt), "relevant-docs.txt");
+    writeFileSync(p, docs);
+    return p;
+  }
+  writeDiffStat(hash, attempt, stat) {
+    const p = join3(this.attemptDir(hash, attempt), "target-diff.stat.txt");
+    writeFileSync(p, stat);
+    return p;
+  }
+  runStart(meta) {
+    this.emit({ ts: new Date().toISOString(), event: "run_start", ...meta });
+    writeFileSync(join3(this.runDir, "metadata.json"), JSON.stringify(meta, null, 2));
+  }
+  runEnd(summary, decisions) {
+    this.emit({ ts: new Date().toISOString(), event: "run_end", summary });
+    writeFileSync(join3(this.runDir, "summary.json"), JSON.stringify({ summary, decisions }, null, 2));
+  }
+  commitStart(hash, message, index, total) {
+    this.emit({ ts: new Date().toISOString(), event: "commit_start", hash, message, index, total });
+  }
+  commitDecision(d) {
+    this.emit({ ts: new Date().toISOString(), event: "commit_decision", ...d });
+  }
+  cherrySkip(hash, message, reason) {
+    this.emit({ ts: new Date().toISOString(), event: "cherry_skip", hash, message, reason });
+  }
+  fetchReset(logs) {
+    this.emit({ ts: new Date().toISOString(), event: "fetch_reset", logs });
+  }
+  error(phase, hash, message, error) {
+    this.emit({ ts: new Date().toISOString(), event: "error", phase, hash, message, error });
+  }
+  get progressFile() {
+    return join3(this.runDir, "progress.json");
+  }
+  saveProgress(decisions, commitIndex) {
+    writeFileSync(this.progressFile, JSON.stringify({ decisions, lastCommitIndex: commitIndex, savedAt: new Date().toISOString() }, null, 2));
+  }
+  loadProgress() {
+    if (!existsSync3(this.progressFile))
+      return null;
+    try {
+      const raw = JSON.parse(readFileSync3(this.progressFile, "utf-8"));
+      return { decisions: raw.decisions ?? [], lastCommitIndex: raw.lastCommitIndex ?? -1 };
+    } catch {
+      return null;
+    }
+  }
+}
+function findResumableRun(baseDir, workBranch) {
+  const runsDir = join3(baseDir, ".backmerge", "runs");
+  if (!existsSync3(runsDir))
+    return null;
+  const runDirs = readdirSync2(runsDir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("run-")).map((e) => e.name).sort().reverse();
+  for (const runId of runDirs) {
+    const runDir = join3(runsDir, runId);
+    const metaFile = join3(runDir, "metadata.json");
+    const progressFile = join3(runDir, "progress.json");
+    const summaryFile = join3(runDir, "summary.json");
+    if (existsSync3(summaryFile))
+      continue;
+    if (!existsSync3(progressFile) || !existsSync3(metaFile))
+      continue;
+    try {
+      const meta = JSON.parse(readFileSync3(metaFile, "utf-8"));
+      if (meta.workBranch !== workBranch)
+        continue;
+      const progress = JSON.parse(readFileSync3(progressFile, "utf-8"));
+      return {
+        runId,
+        runDir,
+        decisions: progress.decisions ?? [],
+        lastCommitIndex: progress.lastCommitIndex ?? -1
+      };
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+var init_audit = () => {};
+
+// src/git.ts
+import simpleGit from "simple-git";
+import { join as join4 } from "path";
+import { tmpdir } from "os";
+function createGit(cwd) {
+  return simpleGit(cwd);
+}
+async function isGitRepo(git) {
+  try {
+    await git.raw(["rev-parse", "--git-dir"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveRef(git, ref) {
+  const result = await git.raw(["rev-parse", "--verify", ref]);
+  return result.trim();
+}
+async function getHead(git) {
+  const result = await git.raw(["rev-parse", "HEAD"]);
+  return result.trim();
+}
+async function getBranches(git) {
+  const summary = await git.branch();
+  const local = summary.all.filter((b) => !b.startsWith("remotes/"));
+  const remote = summary.all.filter((b) => b.startsWith("remotes/") && !b.endsWith("/HEAD")).map((b) => b.replace(/^remotes\//, ""));
+  const localSet = new Set(local);
+  const combined = [...local];
+  for (const r of remote) {
+    const shortName = r.replace(/^[^/]+\//, "");
+    if (!localSet.has(shortName) && !localSet.has(r)) {
+      combined.push(r);
+    }
+  }
+  return combined;
+}
+async function getMergeBase(git, ref1, ref2) {
+  const result = await git.raw(["merge-base", ref1, ref2]);
+  return result.trim();
+}
+async function getCommitsSince(git, since, branch) {
+  const log = await git.log({ from: since, to: branch });
+  return log.all.map((c) => ({ hash: c.hash, message: c.message, date: c.date, author: c.author_name })).reverse();
+}
+async function getCommitDiff(git, hash) {
+  return git.show([hash, "--stat", "--patch"]);
+}
+async function getCommitFiles(git, hash) {
+  const raw = await git.raw(["diff-tree", "--no-commit-id", "--name-only", "-r", hash]);
+  return raw.trim().split(`
+`).filter(Boolean);
+}
+async function getLatestCommitDiff(git, ref) {
+  return git.show([ref, "--stat", "--patch"]);
+}
+async function getDescendantCommitsSince(git, since, ref) {
+  const log = await git.log({ from: since, to: ref });
+  return log.all.map((c) => ({ hash: c.hash, message: c.message, date: c.date, author: c.author_name }));
+}
+function generateWorktreePath(repoName) {
+  const id = Math.random().toString(36).slice(2, 8);
+  return join4(tmpdir(), `backmerge-${repoName}-${id}`);
+}
+async function createDetachedWorktree(git, path, ref) {
+  await git.raw(["worktree", "add", "--detach", path, ref]);
+}
+async function advanceBranch(git, branch, newRef, expectedOld) {
+  await git.raw(["update-ref", `refs/heads/${branch}`, newRef, expectedOld]);
+}
+async function branchExists(git, name) {
+  try {
+    await git.raw(["rev-parse", "--verify", `refs/heads/${name}`]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function createBranch(git, name, startPoint) {
+  await git.raw(["branch", name, startPoint]);
+}
+async function resetBranch(git, name, ref) {
+  await git.raw(["update-ref", `refs/heads/${name}`, ref]);
+}
+async function ensureWorkBranch(git, name, targetRef, resetWorkBranch) {
+  const exists = await branchExists(git, name);
+  if (exists && resetWorkBranch) {
+    const resolved2 = await resolveRef(git, targetRef);
+    await resetBranch(git, name, resolved2);
+    return { created: false, reset: true };
+  }
+  if (exists) {
+    return { created: false, reset: false };
+  }
+  const resolved = await resolveRef(git, targetRef);
+  await createBranch(git, name, resolved);
+  return { created: true, reset: false };
+}
+async function findAlreadyCherryPicked(git, targetRef, sourceRef, mergeBase) {
+  const needed = new Set;
+  const skipped = new Map;
+  try {
+    const result = await git.raw(["cherry", targetRef, sourceRef, mergeBase]);
+    for (const line of result.trim().split(`
+`)) {
+      if (!line.trim())
+        continue;
+      const prefix = line[0];
+      const hash = line.slice(2).trim();
+      if (prefix === "-") {
+        skipped.set(hash, "patch-id match (already cherry-picked)");
+      } else {
+        needed.add(hash);
+      }
+    }
+  } catch {
+    const commits = await getCommitsSince(git, mergeBase, sourceRef);
+    for (const c of commits)
+      needed.add(c.hash);
+  }
+  return { needed, skipped };
+}
+async function validateApply(worktreeGit, beforeHash) {
+  const errors = [];
+  let newCommitHash = null;
+  let newCommitCount = 0;
+  try {
+    const log = await worktreeGit.raw(["log", "--format=%H", `${beforeHash}..HEAD`]);
+    const newHashes = log.trim().split(`
+`).filter(Boolean);
+    newCommitCount = newHashes.length;
+    if (newCommitCount === 0) {
+      errors.push("No new commit created");
+    } else if (newCommitCount === 1) {
+      newCommitHash = newHashes[0];
+    } else {
+      errors.push(`Expected 1 new commit, found ${newCommitCount}`);
+      newCommitHash = newHashes[0];
+    }
+  } catch (e) {
+    errors.push(`Failed to check commits: ${e.message}`);
+  }
+  const status = await worktreeGit.status();
+  const worktreeClean = status.modified.length === 0 && status.created.length === 0 && status.deleted.length === 0 && status.conflicted.length === 0 && status.not_added.length === 0;
+  if (!worktreeClean) {
+    const parts = [];
+    if (status.modified.length)
+      parts.push(`${status.modified.length} modified`);
+    if (status.not_added.length)
+      parts.push(`${status.not_added.length} untracked`);
+    if (status.deleted.length)
+      parts.push(`${status.deleted.length} deleted`);
+    if (status.conflicted.length)
+      parts.push(`${status.conflicted.length} conflicted`);
+    errors.push(`Working tree not clean: ${parts.join(", ")}`);
+  }
+  const conflictMarkers = [];
+  if (newCommitHash) {
+    try {
+      const diffFiles = await worktreeGit.raw(["diff-tree", "--no-commit-id", "--name-only", "-r", newCommitHash]);
+      for (const file of diffFiles.trim().split(`
+`).filter(Boolean)) {
+        try {
+          const content = await worktreeGit.raw(["show", `HEAD:${file}`]);
+          if (/^<{7}\s|^>{7}\s|^={7}$/m.test(content)) {
+            conflictMarkers.push(file);
+          }
+        } catch {}
+      }
+    } catch {}
+  }
+  if (conflictMarkers.length > 0) {
+    errors.push(`Conflict markers in: ${conflictMarkers.join(", ")}`);
+  }
+  return { valid: errors.length === 0, newCommitHash, newCommitCount, worktreeClean, conflictMarkers, errors };
+}
+async function getAppliedDiff(worktreeGit, beforeHash) {
+  return worktreeGit.raw(["diff", beforeHash, "HEAD"]);
+}
+async function getAppliedDiffStat(worktreeGit, beforeHash) {
+  return worktreeGit.raw(["diff", "--stat", beforeHash, "HEAD"]);
+}
+async function resetHard(git, ref) {
+  await git.raw(["reset", "--hard", ref]);
+  await git.raw(["clean", "-fd"]);
+}
+async function fetchOrigin(git) {
+  await git.fetch(["--all", "--prune"]);
+  return "Fetched all remotes";
+}
+async function resetBranchToRemote(git, branch) {
+  try {
+    const remote = (await git.raw(["config", `branch.${branch}.remote`])).trim();
+    const remoteBranch = `${remote}/${branch}`;
+    await git.raw(["rev-parse", "--verify", remoteBranch]);
+    await git.raw(["update-ref", `refs/heads/${branch}`, remoteBranch]);
+    return `Reset ${branch} \u2192 ${remoteBranch}`;
+  } catch {
+    return `No remote tracking for ${branch}, skipped`;
+  }
+}
+async function fetchAndReset(git, branches) {
+  const logs = [];
+  logs.push(await fetchOrigin(git));
+  for (const branch of branches) {
+    logs.push(await resetBranchToRemote(git, branch));
+  }
+  return logs;
+}
+var init_git = () => {};
+
+// src/engine.ts
+async function runEngine(opts, cb) {
+  const {
+    repoPath,
+    sourceRef,
+    targetRef,
+    dryRun = false,
+    listOnly = false,
+    fetch = false,
+    review = true,
+    autoSkip = true
+  } = opts;
+  const config = loadConfig(repoPath, opts.configPath);
+  const effectiveMaxAttempts = opts.maxAttempts ?? config.maxAttempts ?? 2;
+  const effectiveWorkBranch = opts.workBranch ?? config.workBranch;
+  const commitPrefix = config.commitPrefix ?? "backmerge:";
+  if (!checkCodexInstalled())
+    throw new Error("codex CLI not found. Install: npm install -g @openai/codex");
+  const git = createGit(repoPath);
+  if (!await isGitRepo(git))
+    throw new Error(`${repoPath} is not a git repository`);
+  cb.onLog("codex CLI found", "green");
+  if (fetch) {
+    cb.onStatus("Fetching remotes...");
+    const logs = await fetchAndReset(git, []);
+    for (const l of logs)
+      cb.onLog(`  ${l}`, "gray");
+  }
+  cb.onStatus("Discovering repo structure & docs...");
+  const repoCtx = buildRepoContext(repoPath, config);
+  const instrCount = repoCtx.instructions.size;
+  const docCount = repoCtx.docPaths.length;
+  cb.onLog(`Repo: ${repoCtx.structure.type}, ${instrCount} instruction files, ${docCount} doc files`, "gray");
+  if (instrCount > 0) {
+    cb.onLog(`  Instructions: ${[...repoCtx.instructions.keys()].join(", ")}`, "gray");
+  }
+  cb.onStatus("Resolving refs...");
+  const resolvedSource = await resolveRef(git, sourceRef);
+  const resolvedTarget = await resolveRef(git, targetRef);
+  cb.onLog(`Source: ${sourceRef} \u2192 ${resolvedSource.slice(0, 8)}`, "gray");
+  cb.onLog(`Target: ${targetRef} \u2192 ${resolvedTarget.slice(0, 8)}`, "gray");
+  const mergeBase = await getMergeBase(git, resolvedTarget, resolvedSource);
+  cb.onLog(`Merge base: ${mergeBase.slice(0, 8)}`, "gray");
+  const allSourceCommits = await getCommitsSince(git, mergeBase, resolvedSource);
+  const targetCommits = await getDescendantCommitsSince(git, mergeBase, resolvedTarget);
+  cb.onLog(`${allSourceCommits.length} source commits, ${targetCommits.length} target commits since divergence`, "blue");
+  if (allSourceCommits.length === 0) {
+    cb.onLog("No source commits to process!", "green");
+    return {
+      summary: emptyRunSummary(),
+      decisions: [],
+      worktreePath: "",
+      workBranch: "",
+      auditDir: "",
+      commits: []
+    };
+  }
+  cb.onStatus("Detecting already cherry-picked commits...");
+  const { needed, skipped: cherrySkipped } = await findAlreadyCherryPicked(git, resolvedTarget, resolvedSource, mergeBase);
+  const summary = emptyRunSummary();
+  const decisions = [];
+  summary.cherrySkipped = cherrySkipped.size;
+  let commitsToProcess = allSourceCommits.filter((c) => needed.has(c.hash));
+  cb.onLog(`${cherrySkipped.size} cherry-picked (skipped), ${commitsToProcess.length} to process`, "blue");
+  if (opts.startAfter) {
+    const idx = commitsToProcess.findIndex((c) => c.hash.startsWith(opts.startAfter));
+    if (idx >= 0) {
+      commitsToProcess = commitsToProcess.slice(idx + 1);
+      cb.onLog(`Starting after ${opts.startAfter}, ${commitsToProcess.length} remaining`, "gray");
+    }
+  }
+  if (opts.limit && opts.limit < commitsToProcess.length) {
+    commitsToProcess = commitsToProcess.slice(0, opts.limit);
+    cb.onLog(`Limited to first ${opts.limit} commits`, "gray");
+  }
+  summary.total = commitsToProcess.length;
+  if (listOnly) {
+    for (let i = 0;i < commitsToProcess.length; i++) {
+      const c = commitsToProcess[i];
+      cb.onLog(`  ${i + 1}. ${c.hash.slice(0, 8)} ${c.message}`, "white");
+    }
+    return {
+      summary,
+      decisions: [],
+      worktreePath: "",
+      workBranch: "",
+      auditDir: "",
+      commits: commitsToProcess
+    };
+  }
+  const repoName = repoPath.split("/").pop() ?? "repo";
+  const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  let wbName;
+  if (effectiveWorkBranch) {
+    wbName = effectiveWorkBranch;
+    const { created, reset } = await ensureWorkBranch(git, wbName, targetRef, opts.resetWorkBranch ?? false);
+    if (created)
+      cb.onLog(`Created work branch: ${wbName} from ${targetRef}`, "green");
+    else if (reset)
+      cb.onLog(`Reset work branch: ${wbName} to ${targetRef}`, "yellow");
+    else
+      cb.onLog(`Resuming work branch: ${wbName}`, "green");
+  } else {
+    wbName = `backmerge/${ts}`;
+    await ensureWorkBranch(git, wbName, targetRef, false);
+    cb.onLog(`New branch: ${wbName}`, "green");
+  }
+  const wbHead = await resolveRef(git, wbName);
+  cb.onLog(`Work branch HEAD: ${wbHead.slice(0, 8)}`, "gray");
+  const wtPath = generateWorktreePath(repoName);
+  await createDetachedWorktree(git, wtPath, wbHead);
+  cb.onLog(`Eval worktree (detached): ${wtPath}`, "green");
+  const wtGit = createGit(wtPath);
+  const runId = `run-${ts}`;
+  const audit = new AuditLog(wtPath, runId);
+  const runMeta = {
+    runId,
+    startedAt: new Date().toISOString(),
+    sourceRef,
+    targetRef,
+    workBranch: wbName,
+    mergeBase,
+    worktreePath: wtPath,
+    totalCandidates: commitsToProcess.length,
+    cherrySkipped: cherrySkipped.size,
+    dryRun,
+    repoPath
+  };
+  audit.runStart(runMeta);
+  for (const [hash, reason] of cherrySkipped) {
+    const c = allSourceCommits.find((x) => x.hash === hash);
+    if (c)
+      audit.cherrySkip(hash, c.message, reason);
+  }
+  let resumeFromIndex = 0;
+  if (opts.resume && effectiveWorkBranch) {
+    const resumeInfo = findResumableRun(repoPath, effectiveWorkBranch);
+    if (resumeInfo && resumeInfo.lastCommitIndex >= 0) {
+      const prevHashes = new Set(resumeInfo.decisions.map((d) => d.commitHash));
+      for (const d of resumeInfo.decisions) {
+        decisions.push(d);
+        updateSummary(summary, d);
+      }
+      resumeFromIndex = commitsToProcess.findIndex((c) => !prevHashes.has(c.hash));
+      if (resumeFromIndex < 0)
+        resumeFromIndex = commitsToProcess.length;
+      cb.onLog(`Resuming from commit ${resumeFromIndex + 1}/${commitsToProcess.length} (${resumeInfo.decisions.length} already decided)`, "green");
+    }
+  }
+  const sourceLatestDiff = await getLatestCommitDiff(git, resolvedSource);
+  let currentBranchHead = wbHead;
+  for (let i = resumeFromIndex;i < commitsToProcess.length; i++) {
+    const commit = commitsToProcess[i];
+    audit.commitStart(commit.hash, commit.message, i, commitsToProcess.length);
+    cb.onCommitStart(commit, i, commitsToProcess.length);
+    const decision = await processOneCommit({
+      git,
+      wtGit,
+      wtPath,
+      repoPath,
+      commit,
+      index: i,
+      total: commitsToProcess.length,
+      sourceRef,
+      targetRef,
+      sourceLatestDiff,
+      config,
+      repoCtx,
+      audit,
+      cb,
+      dryRun,
+      review,
+      autoSkip,
+      maxAttempts: effectiveMaxAttempts,
+      commitPrefix,
+      workBranch: wbName,
+      workBranchHead: currentBranchHead
+    });
+    if (decision.kind === "applied" && decision.newCommitHash) {
+      currentBranchHead = decision.newCommitHash;
+    }
+    decisions.push(decision);
+    updateSummary(summary, decision);
+    audit.commitDecision(decision);
+    audit.saveProgress(decisions, i);
+    cb.onDecision(commit, decision);
+  }
+  audit.runEnd(summary, decisions);
+  return {
+    summary,
+    decisions,
+    worktreePath: wtPath,
+    workBranch: wbName,
+    auditDir: audit.runDir,
+    commits: commitsToProcess
+  };
+}
+async function processOneCommit(o) {
+  const start = Date.now();
+  const { commit, audit, cb } = o;
+  let touchedPaths = [];
+  try {
+    touchedPaths = await getCommitFiles(o.git, commit.hash);
+  } catch {}
+  const commitCtx = buildCommitContext(o.repoPath, o.repoCtx, o.config, touchedPaths, commit.message);
+  if (commitCtx.includedFiles.length > 0) {
+    audit.writeRelevantDocs(commit.hash, 0, commitCtx.includedFiles.join(`
+`));
+  }
+  let diff;
+  try {
+    diff = await getCommitDiff(o.git, commit.hash);
+    audit.writeSourcePatch(commit.hash, diff);
+  } catch (e) {
+    return mkFailed(commit, "analysis", e.message, start);
+  }
+  cb.onStatus(`Analyzing ${commit.hash.slice(0, 8)}: ${commit.message.slice(0, 50)}`);
+  let analysis;
+  try {
+    analysis = await analyzeCommit({
+      worktreePath: o.wtPath,
+      commitDiff: diff,
+      commitMessage: commit.message,
+      commitHash: commit.hash,
+      sourceBranch: o.sourceRef,
+      targetBranch: o.targetRef,
+      sourceLatestDiff: o.sourceLatestDiff,
+      repoContext: commitCtx.promptBlock
+    });
+    audit.writeAnalysis(commit.hash, 1, analysis);
+    cb.onAnalysis(commit, analysis);
+  } catch (e) {
+    audit.error("analysis", commit.hash, commit.message, e.message);
+    return mkFailed(commit, "analysis", e.message, start);
+  }
+  if (o.autoSkip && analysis.alreadyInTarget === "yes") {
+    cb.onLog(`Auto-skip ${commit.hash.slice(0, 8)}: ${commit.message} (already present)`, "blue");
+    return {
+      kind: "already_applied",
+      commitHash: commit.hash,
+      commitMessage: commit.message,
+      reason: `AI: ${analysis.reasoning.slice(0, 200)}`,
+      durationMs: Date.now() - start
+    };
+  }
+  if (o.dryRun) {
+    const kind = analysis.alreadyInTarget === "partial" ? "would_apply" : "would_apply";
+    return {
+      kind,
+      commitHash: commit.hash,
+      commitMessage: commit.message,
+      reason: analysis.applicationStrategy.slice(0, 300),
+      durationMs: Date.now() - start
+    };
+  }
+  if (o.cb.onAskApply) {
+    const answer = await o.cb.onAskApply(commit, analysis);
+    if (answer === "skip") {
+      return {
+        kind: "skip",
+        commitHash: commit.hash,
+        commitMessage: commit.message,
+        reason: "user skipped",
+        durationMs: Date.now() - start
+      };
+    }
+    if (answer === "quit") {
+      return {
+        kind: "skip",
+        commitHash: commit.hash,
+        commitMessage: commit.message,
+        reason: "user quit",
+        durationMs: Date.now() - start
+      };
+    }
+  }
+  for (let attempt = 1;attempt <= o.maxAttempts; attempt++) {
+    const headBefore = await getHead(o.wtGit);
+    cb.onStatus(`Applying ${commit.hash.slice(0, 8)} (attempt ${attempt}/${o.maxAttempts})...`);
+    let applyResult;
+    try {
+      applyResult = await applyCommit({
+        worktreePath: o.wtPath,
+        commitDiff: diff,
+        commitMessage: commit.message,
+        commitHash: commit.hash,
+        applicationStrategy: analysis.applicationStrategy,
+        sourceBranch: o.sourceRef,
+        targetBranch: o.targetRef,
+        repoContext: commitCtx.promptBlock,
+        commitPrefix: o.commitPrefix
+      });
+      audit.writeAnalysis(commit.hash, attempt, { ...analysis, applyResult });
+    } catch (e) {
+      audit.error("apply", commit.hash, commit.message, e.message);
+      await resetHard(o.wtGit, headBefore);
+      if (attempt === o.maxAttempts)
+        return mkFailed(commit, "apply", e.message, start);
+      continue;
+    }
+    cb.onStatus(`Validating ${commit.hash.slice(0, 8)}...`);
+    const validation = await validateApply(o.wtGit, headBefore);
+    if (!validation.valid) {
+      cb.onLog(`Validation failed: ${validation.errors.join("; ")}`, "red");
+      await resetHard(o.wtGit, headBefore);
+      if (attempt === o.maxAttempts)
+        return mkFailed(commit, "validation", validation.errors.join("; "), start);
+      continue;
+    }
+    if (o.review) {
+      cb.onStatus(`Claude reviewing ${commit.hash.slice(0, 8)}...`);
+      let reviewResult;
+      let packet;
+      try {
+        const appliedDiff = await getAppliedDiff(o.wtGit, headBefore);
+        const appliedDiffStat = await getAppliedDiffStat(o.wtGit, headBefore);
+        packet = {
+          commitHash: commit.hash,
+          commitMessage: commit.message,
+          sourceBranch: o.sourceRef,
+          targetBranch: o.targetRef,
+          analysis,
+          appliedDiff,
+          appliedDiffStat,
+          sourcePatch: diff,
+          relevantDocs: commitCtx.includedFiles.join(`
+`),
+          repoContext: commitCtx.promptBlock,
+          reviewStrictness: o.config.reviewStrictness ?? "normal"
+        };
+        writeReviewPacket(audit, packet, attempt);
+        const headBeforeReview = await getHead(o.wtGit);
+        reviewResult = await reviewAppliedDiff(o.wtPath, packet);
+        audit.writeReviewResult(commit.hash, attempt, reviewResult);
+        const mutation = await verifyReviewIntegrity(o.wtGit, headBeforeReview);
+        if (mutation) {
+          cb.onLog(`Review integrity violation: ${mutation} \u2014 resetting`, "red");
+          audit.error("review_integrity", commit.hash, commit.message, mutation);
+          await resetHard(o.wtGit, headBeforeReview);
+        }
+        cb.onReview?.(commit, reviewResult);
+      } catch (e) {
+        audit.error("review", commit.hash, commit.message, e.message);
+        await resetHard(o.wtGit, headBefore);
+        if (attempt === o.maxAttempts)
+          return mkFailed(commit, "review", e.message, start);
+        continue;
+      }
+      if (!reviewResult.approved) {
+        cb.onLog(`Review rejected: ${reviewResult.issues.join("; ")}`, "red");
+        const maxFixRounds = 2;
+        let fixed = false;
+        for (let fixRound = 1;fixRound <= maxFixRounds; fixRound++) {
+          cb.onStatus(`Codex fixing review issues (round ${fixRound}/${maxFixRounds})...`);
+          try {
+            await fixFromReview({
+              worktreePath: o.wtPath,
+              commitHash: commit.hash,
+              commitMessage: commit.message,
+              reviewIssues: reviewResult.issues,
+              sourceBranch: o.sourceRef,
+              targetBranch: o.targetRef,
+              repoContext: commitCtx.promptBlock,
+              commitPrefix: o.commitPrefix
+            });
+          } catch (e) {
+            cb.onLog(`Fix failed: ${e.message}`, "red");
+            break;
+          }
+          const postFixValidation = await validateApply(o.wtGit, headBefore);
+          if (!postFixValidation.valid) {
+            cb.onLog(`Post-fix validation failed: ${postFixValidation.errors.join("; ")}`, "red");
+            break;
+          }
+          cb.onStatus(`Claude re-reviewing after fix (round ${fixRound})...`);
+          try {
+            const fixedDiff = await getAppliedDiff(o.wtGit, headBefore);
+            const fixedStat = await getAppliedDiffStat(o.wtGit, headBefore);
+            const fixPacket = {
+              ...packet,
+              appliedDiff: fixedDiff,
+              appliedDiffStat: fixedStat
+            };
+            const headBeforeReReview = await getHead(o.wtGit);
+            reviewResult = await reviewAppliedDiff(o.wtPath, fixPacket);
+            audit.writeReviewResult(commit.hash, attempt, {
+              ...reviewResult,
+              fixRound
+            });
+            const reReviewMutation = await verifyReviewIntegrity(o.wtGit, headBeforeReReview);
+            if (reReviewMutation) {
+              cb.onLog(`Re-review integrity violation: ${reReviewMutation} \u2014 resetting`, "red");
+              await resetHard(o.wtGit, headBeforeReReview);
+            }
+            cb.onReview?.(commit, reviewResult);
+            if (reviewResult.approved) {
+              cb.onLog(`Review approved after fix round ${fixRound}`, "green");
+              fixed = true;
+              break;
+            }
+            cb.onLog(`Still rejected after fix round ${fixRound}: ${reviewResult.issues.join("; ")}`, "yellow");
+          } catch (e) {
+            cb.onLog(`Re-review failed: ${e.message}`, "red");
+            break;
+          }
+        }
+        if (!fixed) {
+          await resetHard(o.wtGit, headBefore);
+          if (o.cb.onReviewRejected) {
+            const answer = await o.cb.onReviewRejected(commit, reviewResult);
+            if (answer === "skip" || answer === "quit") {
+              return {
+                kind: "failed",
+                commitHash: commit.hash,
+                commitMessage: commit.message,
+                reason: `Review rejected after ${maxFixRounds} fix rounds: ${reviewResult.issues.join("; ")}`,
+                failedPhase: "review",
+                reviewApproved: false,
+                reviewIssues: reviewResult.issues,
+                durationMs: Date.now() - start
+              };
+            }
+            continue;
+          }
+          if (attempt === o.maxAttempts) {
+            return {
+              kind: "failed",
+              commitHash: commit.hash,
+              commitMessage: commit.message,
+              reason: `Review rejected after ${maxFixRounds} fix rounds: ${reviewResult.issues.join("; ")}`,
+              failedPhase: "review",
+              reviewApproved: false,
+              reviewIssues: reviewResult.issues,
+              durationMs: Date.now() - start
+            };
+          }
+          continue;
+        }
+      }
+      cb.onLog(`Review approved (${reviewResult.confidence})`, "green");
+    }
+    const headAfter = await getHead(o.wtGit);
+    const d = {
+      kind: "applied",
+      commitHash: commit.hash,
+      commitMessage: commit.message,
+      reason: applyResult.notes || "Applied successfully",
+      newCommitHash: validation.newCommitHash ?? undefined,
+      filesChanged: applyResult.filesChanged,
+      reviewApproved: o.review ? true : undefined,
+      durationMs: Date.now() - start
+    };
+    const invariantErrors = validateDecision(d, headBefore, headAfter, o.dryRun);
+    if (invariantErrors.length > 0) {
+      cb.onLog(`Decision invariant violated: ${invariantErrors.join("; ")}`, "red");
+      audit.error("invariant", commit.hash, commit.message, invariantErrors.join("; "));
+      await resetHard(o.wtGit, headBefore);
+      return mkFailed(commit, "invariant", `Decision invariant violated: ${invariantErrors.join("; ")}`, start);
+    }
+    try {
+      await advanceBranch(o.git, o.workBranch, headAfter, o.workBranchHead);
+      cb.onLog(`Advanced ${o.workBranch} \u2192 ${headAfter.slice(0, 8)}`, "green");
+    } catch (e) {
+      cb.onLog(`Branch advance failed (concurrent move?): ${e.message}`, "red");
+      audit.error("branch_advance", commit.hash, commit.message, e.message);
+      await resetHard(o.wtGit, headBefore);
+      return mkFailed(commit, "branch_advance", `CAS failed: ${e.message}`, start);
+    }
+    cb.onLog(`Applied ${commit.hash.slice(0, 8)}: ${commit.message}`, "green");
+    if (applyResult.filesChanged.length > 0) {
+      cb.onLog(`  files: ${applyResult.filesChanged.join(", ")}`, "gray");
+    }
+    return d;
+  }
+  return mkFailed(commit, "apply", "Exhausted all attempts", start);
+}
+function mkFailed(commit, phase, error, start) {
+  return {
+    kind: "failed",
+    commitHash: commit.hash,
+    commitMessage: commit.message,
+    reason: error,
+    error,
+    failedPhase: phase,
+    durationMs: Date.now() - start
+  };
+}
+var init_engine = __esm(() => {
+  init_config();
+  init_context();
+  init_codex();
+  init_review();
+  init_audit();
+  init_git();
+});
+
+// src/batch.ts
+var exports_batch = {};
+__export(exports_batch, {
+  runBatch: () => runBatch
+});
+function emit(obj) {
+  process.stdout.write(JSON.stringify({ ...obj, ts: new Date().toISOString() }) + `
+`);
+}
+async function runBatch(opts) {
+  const cb = {
+    onLog(msg, color) {
+      emit({ event: "log", msg, color });
+    },
+    onStatus(msg) {
+      emit({ event: "status", msg });
+    },
+    onCommitStart(commit, index, total) {
+      emit({ event: "commit_start", hash: commit.hash, message: commit.message, index, total });
+    },
+    onAnalysis(commit, analysis) {
+      emit({ event: "analysis", hash: commit.hash, result: analysis });
+    },
+    onDecision(commit, decision) {
+      emit({ event: "decision", hash: commit.hash, kind: decision.kind, reason: decision.reason });
+    },
+    onReview(commit, review) {
+      emit({ event: "review", hash: commit.hash, approved: review.approved, issues: review.issues });
+    }
+  };
+  try {
+    const result = await runEngine(opts, cb);
+    emit({
+      event: "done",
+      summary: result.summary,
+      worktree: result.worktreePath,
+      branch: result.workBranch,
+      auditDir: result.auditDir
+    });
+    const { summary } = result;
+    if (summary.failed > 0)
+      return 2;
+    return 0;
+  } catch (e) {
+    emit({ event: "fatal", error: e.message });
+    return 1;
+  }
+}
+var init_batch = __esm(() => {
+  init_engine();
+});
+
+// index.ts
+import React2 from "react";
+import { render } from "ink";
+import { resolve } from "path";
+
+// src/app.tsx
+init_engine();
+init_git();
+init_codex();
+import { useState, useEffect, useCallback, useRef } from "react";
+import { Box, Text, useInput, useApp, Static, Newline } from "ink";
+import SelectInput from "ink-select-input";
+import Spinner from "ink-spinner";
+import { jsxDEV, Fragment } from "react/jsx-dev-runtime";
+function shortHash(h) {
+  return h.slice(0, 8);
+}
+function progressBar(current, total, width = 30) {
+  const ratio = Math.min(current / total, 1);
+  const filled = Math.round(ratio * width);
+  return `[${"\u2588".repeat(filled)}${"\u2591".repeat(width - filled)}] ${current}/${total}`;
+}
+function Header({
+  source,
+  target,
+  current,
+  total,
+  worktree
+}) {
+  return /* @__PURE__ */ jsxDEV(Box, {
+    flexDirection: "column",
+    marginBottom: 1,
+    children: [
+      /* @__PURE__ */ jsxDEV(Box, {
+        children: [
+          /* @__PURE__ */ jsxDEV(Text, {
+            bold: true,
+            color: "cyan",
+            children: "\u256D\u2500 backmerge"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(Text, {
+            color: "gray",
+            children: " \u2014 curated branch reconciliation"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      target && source && /* @__PURE__ */ jsxDEV(Box, {
+        children: [
+          /* @__PURE__ */ jsxDEV(Text, {
+            color: "cyan",
+            children: [
+              "\u2502",
+              " "
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV(Text, {
+            color: "green",
+            children: target
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(Text, {
+            color: "gray",
+            children: " \u2190 "
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(Text, {
+            color: "magenta",
+            children: source
+          }, undefined, false, undefined, this),
+          current !== undefined && total !== undefined && /* @__PURE__ */ jsxDEV(Fragment, {
+            children: [
+              /* @__PURE__ */ jsxDEV(Text, {
+                color: "gray",
+                children: " "
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV(Text, {
+                children: progressBar(current, total)
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      worktree && /* @__PURE__ */ jsxDEV(Box, {
+        children: [
+          /* @__PURE__ */ jsxDEV(Text, {
+            color: "cyan",
+            children: [
+              "\u2502",
+              " "
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV(Text, {
+            dimColor: true,
+            children: [
+              "worktree: ",
+              worktree
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV(Text, {
+        color: "cyan",
+        children: [
+          "\u2570",
+          "\u2500".repeat(60)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function ActionBar({ actions }) {
+  return /* @__PURE__ */ jsxDEV(Box, {
+    gap: 2,
+    marginTop: 1,
+    children: actions.map((a) => /* @__PURE__ */ jsxDEV(Box, {
+      children: [
+        /* @__PURE__ */ jsxDEV(Text, {
+          color: "gray",
+          children: "["
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV(Text, {
+          bold: true,
+          color: a.color ?? "cyan",
+          children: a.key
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV(Text, {
+          color: "gray",
+          children: "] "
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV(Text, {
+          children: a.label
+        }, undefined, false, undefined, this)
+      ]
+    }, a.key, true, undefined, this))
+  }, undefined, false, undefined, this);
+}
+function App({ repoPath, engineOpts }) {
+  const { exit } = useApp();
+  const [phase, setPhase] = useState("checking-prereqs");
+  const [branches, setBranches] = useState([]);
+  const [source, setSource] = useState(engineOpts.sourceRef ?? "");
+  const [target, setTarget] = useState(engineOpts.targetRef ?? "");
+  const [logs, setLogs] = useState([]);
+  const [statusText, setStatusText] = useState("");
+  const [error, setError] = useState("");
+  const [currentCommit, setCurrentCommit] = useState(null);
+  const [currentAnalysis, setCurrentAnalysis] = useState(null);
+  const [currentReview, setCurrentReview] = useState(null);
+  const [currentIdx, setCurrentIdx] = useState(0);
+  const [totalCommits, setTotalCommits] = useState(0);
+  const [worktreePath, setWorktreePath] = useState("");
+  const [result, setResult] = useState(null);
+  const askResolverRef = useRef(null);
+  const reviewResolverRef = useRef(null);
+  const addLog = useCallback((text, color) => {
+    setLogs((prev) => [...prev, { id: `${Date.now()}-${Math.random()}`, text, color }]);
+  }, []);
+  useEffect(() => {
+    if (phase !== "checking-prereqs")
+      return;
+    (async () => {
+      if (!checkCodexInstalled()) {
+        setError("codex CLI not found");
+        setPhase("error");
+        return;
+      }
+      const git = createGit(repoPath);
+      if (!await isGitRepo(git)) {
+        setError(`${repoPath} is not a git repo`);
+        setPhase("error");
+        return;
+      }
+      const b = await getBranches(git);
+      setBranches(b);
+      addLog(`Found ${b.length} branches`, "gray");
+      if (source && target)
+        setPhase("confirm");
+      else if (target)
+        setPhase("select-source");
+      else
+        setPhase("select-target");
+    })().catch((e) => {
+      setError(e.message);
+      setPhase("error");
+    });
+  }, [phase, repoPath, addLog, source, target]);
+  const startEngine = useCallback(async () => {
+    setPhase("running");
+    const opts = { repoPath, sourceRef: source, targetRef: target, ...engineOpts };
+    const cb = {
+      onLog: addLog,
+      onStatus: setStatusText,
+      onCommitStart(commit, index, total) {
+        setCurrentCommit(commit);
+        setCurrentIdx(index);
+        setTotalCommits(total);
+      },
+      onAnalysis(_commit, analysis) {
+        setCurrentAnalysis(analysis);
+      },
+      onDecision() {},
+      onReview(_commit, review) {
+        setCurrentReview(review);
+      },
+      async onAskApply(commit, analysis) {
+        setCurrentCommit(commit);
+        setCurrentAnalysis(analysis);
+        setPhase("show-analysis");
+        return new Promise((resolve) => {
+          askResolverRef.current = resolve;
+        });
+      },
+      async onReviewRejected(commit, review) {
+        setCurrentCommit(commit);
+        setCurrentReview(review);
+        setPhase("review-result");
+        return new Promise((resolve) => {
+          reviewResolverRef.current = resolve;
+        });
+      }
+    };
+    try {
+      const r = await runEngine(opts, cb);
+      setResult(r);
+      setWorktreePath(r.worktreePath);
+      setPhase("done");
+    } catch (e) {
+      setError(e.message);
+      setPhase("error");
+    }
+  }, [repoPath, source, target, engineOpts, addLog]);
+  useInput((input, key) => {
+    if (phase === "show-analysis" && askResolverRef.current) {
+      if (input === "a" || input === "A") {
+        askResolverRef.current("apply");
+        askResolverRef.current = null;
+        setPhase("running");
+      } else if (input === "s" || input === "S") {
+        askResolverRef.current("skip");
+        askResolverRef.current = null;
+        setPhase("running");
+      } else if (input === "q" || input === "Q") {
+        askResolverRef.current("quit");
+        askResolverRef.current = null;
+        setPhase("done");
+      }
+    } else if (phase === "review-result" && reviewResolverRef.current) {
+      if (input === "r" || input === "R") {
+        reviewResolverRef.current("retry");
+        reviewResolverRef.current = null;
+        setPhase("running");
+      } else if (input === "s" || input === "S") {
+        reviewResolverRef.current("skip");
+        reviewResolverRef.current = null;
+        setPhase("running");
+      } else if (input === "q" || input === "Q") {
+        reviewResolverRef.current("quit");
+        reviewResolverRef.current = null;
+        setPhase("done");
+      }
+    } else if (phase === "done" || phase === "error") {
+      if (input === "q" || input === "Q" || key.escape || key.return)
+        exit();
+    } else if (phase === "confirm") {
+      if (input === "y" || input === "Y" || key.return)
+        startEngine();
+      else if (input === "n" || input === "N" || key.escape)
+        exit();
+    }
+  }, { isActive: ["show-analysis", "review-result", "done", "error", "confirm"].includes(phase) });
+  const branchItems = branches.map((b) => ({ label: b, value: b }));
+  return /* @__PURE__ */ jsxDEV(Box, {
+    flexDirection: "column",
+    paddingX: 1,
+    children: [
+      /* @__PURE__ */ jsxDEV(Header, {
+        source: source || undefined,
+        target: target || undefined,
+        current: totalCommits > 0 ? currentIdx + 1 : undefined,
+        total: totalCommits || undefined,
+        worktree: worktreePath || undefined
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(Static, {
+        items: logs,
+        children: (entry) => /* @__PURE__ */ jsxDEV(Text, {
+          color: entry.color ?? "white",
+          children: entry.text
+        }, entry.id, false, undefined, this)
+      }, undefined, false, undefined, this),
+      phase === "checking-prereqs" && /* @__PURE__ */ jsxDEV(Box, {
+        children: [
+          /* @__PURE__ */ jsxDEV(Text, {
+            color: "cyan",
+            children: /* @__PURE__ */ jsxDEV(Spinner, {
+              type: "dots"
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(Text, {
+            children: " Checking prerequisites..."
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      phase === "select-target" && branches.length > 0 && /* @__PURE__ */ jsxDEV(Box, {
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsxDEV(Text, {
+            bold: true,
+            color: "green",
+            children: "Select target branch (where changes merge INTO):"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(SelectInput, {
+            items: branchItems,
+            onSelect: (item) => {
+              setTarget(item.value);
+              setPhase("select-source");
+            }
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      phase === "select-source" && /* @__PURE__ */ jsxDEV(Box, {
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsxDEV(Text, {
+            bold: true,
+            color: "magenta",
+            children: "Select source branch (where changes come FROM):"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(SelectInput, {
+            items: branchItems.filter((b) => b.value !== target),
+            onSelect: (item) => {
+              setSource(item.value);
+              setPhase("confirm");
+            }
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      phase === "confirm" && /* @__PURE__ */ jsxDEV(Box, {
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsxDEV(Box, {
+            flexDirection: "column",
+            borderStyle: "round",
+            borderColor: "yellow",
+            paddingX: 1,
+            children: [
+              /* @__PURE__ */ jsxDEV(Text, {
+                bold: true,
+                children: "Confirm backmerge"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV(Newline, {}, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV(Box, {
+                children: [
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    children: "Source: "
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    bold: true,
+                    color: "magenta",
+                    children: source
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV(Box, {
+                children: [
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    children: "Target: "
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    bold: true,
+                    color: "green",
+                    children: target
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              engineOpts.workBranch && /* @__PURE__ */ jsxDEV(Box, {
+                children: [
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    children: "Work branch: "
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    bold: true,
+                    color: "cyan",
+                    children: engineOpts.workBranch
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              engineOpts.dryRun && /* @__PURE__ */ jsxDEV(Text, {
+                color: "yellow",
+                children: "DRY RUN"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV(ActionBar, {
+            actions: [
+              { key: "y", label: "Proceed", color: "green" },
+              { key: "n", label: "Cancel", color: "red" }
+            ]
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      phase === "running" && /* @__PURE__ */ jsxDEV(Box, {
+        children: [
+          /* @__PURE__ */ jsxDEV(Text, {
+            color: "cyan",
+            children: /* @__PURE__ */ jsxDEV(Spinner, {
+              type: "dots"
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(Text, {
+            children: [
+              " ",
+              statusText
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      phase === "show-analysis" && currentCommit && currentAnalysis && /* @__PURE__ */ jsxDEV(Box, {
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsxDEV(Box, {
+            flexDirection: "column",
+            borderStyle: "round",
+            borderColor: "blue",
+            paddingX: 1,
+            marginBottom: 1,
+            children: [
+              /* @__PURE__ */ jsxDEV(Box, {
+                children: [
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    bold: true,
+                    color: "blue",
+                    children: [
+                      "Commit ",
+                      currentIdx + 1,
+                      "/",
+                      totalCommits
+                    ]
+                  }, undefined, true, undefined, this),
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    color: "gray",
+                    children: " \u2022 "
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    color: "yellow",
+                    children: shortHash(currentCommit.hash)
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV(Text, {
+                bold: true,
+                children: currentCommit.message
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV(Box, {
+            flexDirection: "column",
+            borderStyle: "round",
+            borderColor: "magenta",
+            paddingX: 1,
+            marginBottom: 1,
+            children: [
+              /* @__PURE__ */ jsxDEV(Box, {
+                children: [
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    bold: true,
+                    color: "magenta",
+                    children: [
+                      "Analysis \u2502",
+                      " "
+                    ]
+                  }, undefined, true, undefined, this),
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    bold: true,
+                    color: currentAnalysis.alreadyInTarget === "yes" ? "green" : currentAnalysis.alreadyInTarget === "partial" ? "yellow" : "red",
+                    children: currentAnalysis.alreadyInTarget === "yes" ? "ALREADY PRESENT" : currentAnalysis.alreadyInTarget === "partial" ? "PARTIAL" : "MISSING"
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV(Newline, {}, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV(Text, {
+                bold: true,
+                children: "Summary:"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV(Text, {
+                wrap: "wrap",
+                children: currentAnalysis.summary
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV(Newline, {}, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV(Text, {
+                bold: true,
+                children: "Reasoning:"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV(Text, {
+                wrap: "wrap",
+                dimColor: true,
+                children: currentAnalysis.reasoning
+              }, undefined, false, undefined, this),
+              currentAnalysis.alreadyInTarget !== "yes" && /* @__PURE__ */ jsxDEV(Fragment, {
+                children: [
+                  /* @__PURE__ */ jsxDEV(Newline, {}, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    bold: true,
+                    color: "yellow",
+                    children: "Strategy:"
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    wrap: "wrap",
+                    children: currentAnalysis.applicationStrategy
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV(ActionBar, {
+            actions: [
+              ...currentAnalysis.alreadyInTarget !== "yes" ? [{ key: "a", label: "Apply", color: "green" }] : [],
+              { key: "s", label: "Skip", color: "yellow" },
+              { key: "q", label: "Quit", color: "red" }
+            ]
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      phase === "review-result" && currentCommit && currentReview && /* @__PURE__ */ jsxDEV(Box, {
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsxDEV(Box, {
+            flexDirection: "column",
+            borderStyle: "round",
+            borderColor: "red",
+            paddingX: 1,
+            marginBottom: 1,
+            children: [
+              /* @__PURE__ */ jsxDEV(Text, {
+                bold: true,
+                color: "red",
+                children: [
+                  "Review REJECTED \u2014 ",
+                  shortHash(currentCommit.hash)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV(Newline, {}, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV(Text, {
+                wrap: "wrap",
+                children: currentReview.summary
+              }, undefined, false, undefined, this),
+              currentReview.issues.map((issue, i) => /* @__PURE__ */ jsxDEV(Text, {
+                color: "red",
+                children: [
+                  " ",
+                  "\u2022 ",
+                  issue
+                ]
+              }, i, true, undefined, this))
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV(Text, {
+            color: "yellow",
+            children: "Changes rolled back."
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(ActionBar, {
+            actions: [
+              { key: "r", label: "Retry", color: "cyan" },
+              { key: "s", label: "Skip", color: "yellow" },
+              { key: "q", label: "Quit", color: "red" }
+            ]
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      phase === "done" && result && /* @__PURE__ */ jsxDEV(Box, {
+        flexDirection: "column",
+        marginTop: 1,
+        children: [
+          /* @__PURE__ */ jsxDEV(Box, {
+            flexDirection: "column",
+            borderStyle: "double",
+            borderColor: "green",
+            paddingX: 2,
+            paddingY: 1,
+            children: [
+              /* @__PURE__ */ jsxDEV(Text, {
+                bold: true,
+                color: "green",
+                children: "Backmerge Complete"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV(Newline, {}, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV(Box, {
+                children: [
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    children: "Applied: "
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    bold: true,
+                    color: "green",
+                    children: result.summary.applied
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV(Box, {
+                children: [
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    children: "Would apply: "
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    bold: true,
+                    color: "cyan",
+                    children: result.summary.wouldApply
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV(Box, {
+                children: [
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    children: "Already applied: "
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    bold: true,
+                    color: "blue",
+                    children: result.summary.alreadyApplied
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV(Box, {
+                children: [
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    children: "Skipped: "
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    bold: true,
+                    color: "yellow",
+                    children: result.summary.skipped
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV(Box, {
+                children: [
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    children: "Cherry-skipped: "
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    bold: true,
+                    color: "cyan",
+                    children: result.summary.cherrySkipped
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV(Box, {
+                children: [
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    children: "Failed: "
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    bold: true,
+                    color: "red",
+                    children: result.summary.failed
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV(Newline, {}, undefined, false, undefined, this),
+              result.worktreePath && /* @__PURE__ */ jsxDEV(Text, {
+                dimColor: true,
+                children: [
+                  "Worktree: ",
+                  result.worktreePath
+                ]
+              }, undefined, true, undefined, this),
+              result.workBranch && /* @__PURE__ */ jsxDEV(Text, {
+                dimColor: true,
+                children: [
+                  "Branch: ",
+                  result.workBranch
+                ]
+              }, undefined, true, undefined, this),
+              result.auditDir && /* @__PURE__ */ jsxDEV(Text, {
+                dimColor: true,
+                children: [
+                  "Audit: ",
+                  result.auditDir
+                ]
+              }, undefined, true, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV(ActionBar, {
+            actions: [{ key: "q", label: "Exit", color: "gray" }]
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      phase === "error" && /* @__PURE__ */ jsxDEV(Box, {
+        flexDirection: "column",
+        marginTop: 1,
+        children: [
+          /* @__PURE__ */ jsxDEV(Box, {
+            borderStyle: "round",
+            borderColor: "red",
+            paddingX: 1,
+            children: /* @__PURE__ */ jsxDEV(Text, {
+              color: "red",
+              bold: true,
+              children: [
+                "Error: ",
+                error
+              ]
+            }, undefined, true, undefined, this)
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(ActionBar, {
+            actions: [{ key: "q", label: "Exit", color: "gray" }]
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// index.ts
+init_config();
+var args = process.argv.slice(2);
+var repoPath = ".";
+var sourceRef = "";
+var targetRef = "";
+var workBranch = "";
+var resetWorkBranch = false;
+var dryRun = false;
+var listOnly = false;
+var doFetch = false;
+var review = true;
+var autoSkip = true;
+var maxAttempts = 2;
+var startAfter = "";
+var limit = 0;
+var configPath = "";
+var batch = false;
+var resume = true;
+var showHelp = false;
+for (let i = 0;i < args.length; i++) {
+  const arg = args[i];
+  if (arg === "--help" || arg === "-h")
+    showHelp = true;
+  else if (arg === "--batch" || arg === "-b")
+    batch = true;
+  else if (arg === "--dry-run")
+    dryRun = true;
+  else if (arg === "--list-only")
+    listOnly = true;
+  else if (arg === "--fetch" || arg === "-f")
+    doFetch = true;
+  else if (arg === "--no-fetch")
+    doFetch = false;
+  else if (arg === "--no-review")
+    review = false;
+  else if (arg === "--no-auto-skip")
+    autoSkip = false;
+  else if (arg === "--reset-work-branch") {
+    resetWorkBranch = true;
+    resume = false;
+  } else if (arg === "--no-resume")
+    resume = false;
+  else if (arg === "--source-ref" && args[i + 1])
+    sourceRef = args[++i];
+  else if (arg === "--target-ref" && args[i + 1])
+    targetRef = args[++i];
+  else if (arg === "--work-branch" && args[i + 1])
+    workBranch = args[++i];
+  else if (arg === "--start-after" && args[i + 1])
+    startAfter = args[++i];
+  else if (arg === "--limit" && args[i + 1])
+    limit = parseInt(args[++i], 10) || 0;
+  else if (arg === "--max-attempts" && args[i + 1])
+    maxAttempts = parseInt(args[++i], 10) || 2;
+  else if (arg === "--config" && args[i + 1])
+    configPath = args[++i];
+  else if (!arg.startsWith("-"))
+    repoPath = arg;
+}
+if (showHelp) {
+  console.log(`
+xab \u2014 AI-powered curated branch reconciliation
+
+Usage:
+  xab [repo-path] [options]
+
+Ref selection:
+  --source-ref <ref>      Source branch/ref (where changes come FROM)
+  --target-ref <ref>      Target branch/ref (where changes merge INTO)
+  --work-branch <name>    Persistent work branch (resumes if exists)
+  --reset-work-branch     Force-reset work branch to target ref
+
+Modes:
+  --batch, -b             Unattended batch mode (JSONL to stdout)
+  --dry-run               Analyze only, never create commits
+  --list-only             List candidate commits and exit
+
+Filtering:
+  --start-after <sha>     Skip commits up to and including this hash
+  --limit <n>             Process at most n commits
+
+Behavior:
+  --fetch, -f             Fetch remotes before starting
+  --no-fetch              Skip fetch (default)
+  --no-review             Skip Claude review pass
+  --no-auto-skip          Don't auto-skip commits AI identifies as present
+  --max-attempts <n>      Max retries per commit (default: 2)
+  --no-resume             Don't resume from interrupted runs (default: auto-resume)
+  --config <path>         Path to config file (default: auto-discover)
+  --help, -h              Show this help
+
+Config:
+  Place .xab.json in the target repo for persistent settings:
+  - sourceRef, targetRef, workBranch: default refs
+  - instructionFiles: extra docs to include in AI context
+  - docRoutes: map commit paths/keywords to relevant docs
+  - promptHints: extra instructions for AI
+  - pathRemaps: source\u2192target path mappings
+  - reviewStrictness: "strict" | "normal" | "lenient"
+  - maxAttempts, commitPrefix
+
+Pipeline:
+  1. Discover repo structure, instruction files, docs
+  2. Resolve refs, compute merge base
+  3. Detect already cherry-picked commits (git patch-id)
+  4. For each remaining commit:
+     a. Build per-commit context (relevant docs, repo hints)
+     b. Codex (gpt-5.4, high) analyzes: present/missing/partial
+     c. Auto-skip if already present
+     d. Codex applies changes (curated merge, not cherry-pick)
+     e. Validate: exactly 1 clean commit, no conflict markers
+     f. Claude (opus 4.6, high) reviews applied diff
+     g. Branch advances only after review approval
+  5. Audit log + artifacts written to .xab/runs/
+
+Models:
+  - Analysis/Apply: gpt-5.4 (high reasoning effort) via Codex SDK
+  - Review: claude-opus-4-6 (high reasoning effort) via Claude Agent SDK
+
+Exit codes (batch): 0=success, 1=fatal, 2=partial failure
+
+Prerequisites:
+  - codex CLI: npm install -g @openai/codex
+  - Claude Code CLI: npm install -g @anthropic-ai/claude-code
+`);
+  process.exit(0);
+}
+var resolvedPath = resolve(repoPath);
+var repoConfig = loadConfig(resolvedPath, configPath || undefined);
+if (!sourceRef && repoConfig.sourceRef)
+  sourceRef = repoConfig.sourceRef;
+if (!targetRef && repoConfig.targetRef)
+  targetRef = repoConfig.targetRef;
+if (!workBranch && repoConfig.workBranch)
+  workBranch = repoConfig.workBranch;
+if (repoConfig.maxAttempts && maxAttempts === 2)
+  maxAttempts = repoConfig.maxAttempts;
+var engineOpts = {
+  ...sourceRef && { sourceRef },
+  ...targetRef && { targetRef },
+  ...workBranch && { workBranch },
+  ...resetWorkBranch && { resetWorkBranch },
+  ...dryRun && { dryRun },
+  ...listOnly && { listOnly },
+  ...doFetch && { fetch: doFetch },
+  review,
+  autoSkip,
+  resume,
+  maxAttempts,
+  ...startAfter && { startAfter },
+  ...limit > 0 && { limit },
+  ...configPath && { configPath }
+};
+if (batch || listOnly) {
+  if (!sourceRef || !targetRef) {
+    console.error("Error: --batch/--list-only requires --source-ref and --target-ref (via flags or .xab.json)");
+    process.exit(1);
+  }
+  const { runBatch: runBatch2 } = await Promise.resolve().then(() => (init_batch(), exports_batch));
+  const exitCode = await runBatch2({
+    repoPath: resolvedPath,
+    sourceRef,
+    targetRef,
+    ...engineOpts
+  });
+  process.exit(exitCode);
+} else {
+  console.clear();
+  const { waitUntilExit } = render(React2.createElement(App, { repoPath: resolvedPath, engineOpts }));
+  await waitUntilExit();
+}