@ordewell/core 0.5.0 → 0.5.1

package/dist/index.mjs

@@ -70,6 +70,7 @@ import {
 } from "./chunk-HPNUFBIT.mjs";
 import {
   SELF_REPO,
+  capConflictFiles,
   handoffOf,
   integrationBranchFor,
   integrationBranchNameOf,
@@ -78,7 +79,7 @@ import {
   migratePlanStateIsolation,
   repoRootOf,
   taskIsolationOf
-} from "./chunk-HQICT7HQ.mjs";
+} from "./chunk-T2S5O36I.mjs";
 
 // src/interfaces/IFileSystem.ts
 var GREP_DEFAULT_HEAD_LIMIT = 100;
@@ -2770,14 +2771,14 @@ var PendingApprovals = class {
   ask(request) {
     const id = `ap-${Date.now()}-${counter++}`;
     const pending = { id, request, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const settle = (granted) => {
         const entry = this.entries.get(id);
         if (!entry) return;
         clearTimeout(entry.timer);
         this.entries.delete(id);
         this.opts.onSettled?.(id, granted);
-        resolve5(granted);
+        resolve6(granted);
       };
       const timer = setTimeout(() => settle(false), this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
       timer.unref?.();
@@ -3475,6 +3476,10 @@ function normalizeGeminiModel(id) {
 function commaList(raw) {
   return (raw || "").split(",").map((s) => s.trim()).filter(Boolean);
 }
+function nonNegativeInt(raw, fallback) {
+  const trimmed = (raw ?? "").trim();
+  return /^\d+$/.test(trimmed) ? Number(trimmed) : fallback;
+}
 var BaseConfig = class {
   // --- Legacy named getters (backward compat) ---
   get openAiBaseUrl() {
@@ -3697,6 +3702,9 @@ var BaseConfig = class {
   get worktreeLinks() {
     return commaList(process.env.ORDEWELL_WORKTREE_LINKS);
   }
+  get conflictRepairAttempts() {
+    return nonNegativeInt(process.env.ORDEWELL_CONFLICT_REPAIR_ATTEMPTS, 2);
+  }
   get approvalMode() {
     const raw = (process.env.ORDEWELL_APPROVAL_MODE || "").trim().toLowerCase();
     return raw === "allow" || raw === "deny" ? raw : "ask";
@@ -3756,13 +3764,17 @@ function landedNotice(landed) {
   if (landed.length === 0) return "Nothing was merged.";
   return landed.length === 1 ? `${landed[0]} was merged already and stays merged.` : `${landed.join(", ")} were merged already and stay merged.`;
 }
-function describeMergeResult(result, branch, group) {
+function repairedNotice(repaired) {
+  const named = repaired.map((t) => `${t.title} (${capConflictFiles(t.repairedFiles ?? [])})`);
+  const list = named.length === 1 ? named[0] : `${named.slice(0, -1).join(", ")} and ${named[named.length - 1]}`;
+  return `${list} landed through ${repaired.length === 1 ? "a conflict repair" : "conflict repairs"}.`;
+}
+function describeMergeResult(result, branch, group, repaired = []) {
   switch (result.outcome) {
-    case "merged":
-      return {
-        level: "info",
-        message: group ? `Merged ${branch} into the checked-out branch of every repository.` : `Merged ${branch} into your checked-out branch.`
-      };
+    case "merged": {
+      const base = group ? `Merged ${branch} into the checked-out branch of every repository.` : `Merged ${branch} into your checked-out branch.`;
+      return { level: "info", message: repaired.length > 0 ? `${base} ${repairedNotice(repaired)}` : base };
+    }
     case "blocked":
       return { level: "warn", message: `Merged nothing, so every tree is as it was: ${result.blocked.map(blockNotice).join("; ")}.` };
     case "conflict":
@@ -3783,7 +3795,7 @@ import { execFile, exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
 import { randomBytes } from "crypto";
 import * as fs4 from "fs";
-import * as path7 from "path";
+import * as path8 from "path";
 
 // src/utils/shellPath.ts
 import { exec } from "child_process";
@@ -3812,28 +3824,28 @@ function posixBinDirs() {
   ];
 }
 function windowsBinDirs(env, home) {
-  const join21 = (...parts) => path4.win32.join(...parts);
-  const under = (base, ...parts) => base ? [join21(base, ...parts)] : [];
+  const join22 = (...parts) => path4.win32.join(...parts);
+  const under = (base, ...parts) => base ? [join22(base, ...parts)] : [];
   const appData = env.APPDATA;
   const localAppData = env.LOCALAPPDATA;
   const programData = env.ProgramData;
   return [
     // Native per-user installers, PowerShell-driven and otherwise.
-    join21(home, ".local", "bin"),
-    join21(home, ".opencode", "bin"),
-    join21(home, ".claude", "bin"),
-    join21(home, ".codex", "bin"),
+    join22(home, ".local", "bin"),
+    join22(home, ".opencode", "bin"),
+    join22(home, ".claude", "bin"),
+    join22(home, ".codex", "bin"),
     ...under(localAppData, "Programs", "claude"),
     // Node package managers. npm's global prefix is `%APPDATA%\npm`; the
     // literal spelling is kept as a fallback for a host that does not export
     // APPDATA (a service account, a stripped CI container).
     ...under(appData, "npm"),
-    join21(home, "AppData", "Roaming", "npm"),
+    join22(home, "AppData", "Roaming", "npm"),
     ...under(localAppData, "pnpm"),
     ...under(localAppData, "Yarn", "bin"),
-    join21(home, ".bun", "bin"),
+    join22(home, ".bun", "bin"),
     // Windows package managers.
-    join21(home, "scoop", "shims"),
+    join22(home, "scoop", "shims"),
     ...under(env.SCOOP, "shims"),
     ...under(env.SCOOP_GLOBAL ?? programData, "scoop", "shims"),
     ...under(programData, "chocolatey", "bin"),
@@ -3843,7 +3855,7 @@ function windowsBinDirs(env, home) {
     ...under(localAppData, "Microsoft", "WindowsApps"),
     // Version managers. Volta's Windows home is not the POSIX `~/.volta`.
     ...under(localAppData, "Volta", "bin"),
-    join21(home, ".volta", "bin")
+    join22(home, ".volta", "bin")
   ];
 }
 function wellKnownBinDirs(deps = {}) {
@@ -3947,6 +3959,7 @@ function savePrdMarkdown(workspace, slug2, markdown) {
 
 // src/services/worktreeLink.ts
 import * as fs3 from "fs";
+import * as path7 from "path";
 function linkPath(source, target, platform, hardLink = fs3.linkSync) {
   const isDir = fs3.statSync(source).isDirectory();
   if (platform !== "win32") {
@@ -3965,6 +3978,55 @@ function linkPath(source, target, platform, hardLink = fs3.linkSync) {
     return "copy";
   }
 }
+function mirrorDir(source, target, opts) {
+  const copied = [];
+  const links = [];
+  const mirror = (from, to, prefix, top) => {
+    fs3.mkdirSync(to, { recursive: true });
+    for (const entry of fs3.readdirSync(from, { withFileTypes: true })) {
+      const name = path7.join(prefix, entry.name);
+      const at = { from: path7.join(from, entry.name), to: path7.join(to, entry.name), name };
+      if (entry.isSymbolicLink()) links.push(at);
+      else if (top && entry.isDirectory() && (entry.name.startsWith("@") || entry.name === ".bin")) mirror(at.from, at.to, name, false);
+      else if (linkPath(at.from, at.to, opts.platform, opts.hardLink) === "copy") copied.push(name);
+    }
+  };
+  mirror(source, target, "", true);
+  let pending = links;
+  for (let before = Infinity; pending.length > 0 && pending.length < before; ) {
+    before = pending.length;
+    pending = pending.filter((link) => {
+      const kind = relink(link.from, link.to, opts);
+      if (kind === "copy") copied.push(link.name);
+      return kind === null;
+    });
+  }
+  return copied;
+}
+function relink(from, to, opts) {
+  const text = fs3.readlinkSync(from);
+  const pointee = path7.isAbsolute(text) ? rebased(text, opts) : text;
+  if (opts.platform !== "win32") {
+    if (!fs3.existsSync(path7.resolve(path7.dirname(to), pointee)) && fs3.existsSync(path7.resolve(path7.dirname(from), pointee))) {
+      fs3.symlinkSync(rebased(path7.resolve(path7.dirname(from), pointee), opts), to);
+      return "symlink";
+    }
+    fs3.symlinkSync(pointee, to);
+    return "symlink";
+  }
+  const resolved = fs3.existsSync(path7.resolve(path7.dirname(to), pointee)) ? path7.resolve(path7.dirname(to), pointee) : rebased(path7.resolve(path7.dirname(from), pointee), opts);
+  try {
+    fs3.statSync(resolved);
+  } catch {
+    return null;
+  }
+  return linkPath(resolved, to, opts.platform, opts.hardLink);
+}
+function rebased(pointee, opts) {
+  const rel = path7.relative(opts.from, pointee);
+  const inside = rel !== "" && !rel.startsWith("..") && !path7.isAbsolute(rel);
+  return inside && !rel.split(/[\\/]/).includes("node_modules") ? path7.join(opts.to, rel) : pointee;
+}
 
 // src/services/GitWorktreeIsolation.ts
 var execFileAsync = promisify2(execFile);
@@ -3979,15 +4041,17 @@ var INHERITED_GIT_VARS = ["GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_COM
 var LINKED_ARTIFACTS = /* @__PURE__ */ new Set(["node_modules", "vendor", ".venv", ".claude", ".opencode", ".codegraph", ".envrc"]);
 var isEnvFile = (name) => name.startsWith(".env");
 var INTEGRATION_DIR = "integration";
+var RUN_BRANCH = /^ordewell\/([^/]+)\/[^/]+$/;
+var RUN_WORKTREE = /.*[\\/]\.ordewell[\\/]worktrees[\\/]([^\\/]+)[\\/]/;
 var NESTED_REPO_DEPTH = 2;
 var NEVER_SCANNED = /* @__PURE__ */ new Set([".git", STATE_DIR, "node_modules"]);
 var GITLINK_MODE = "160000";
 function isInside(parent, child) {
-  const rel = path7.relative(parent, child);
-  return rel !== "" && !rel.startsWith("..") && !path7.isAbsolute(rel);
+  const rel = path8.relative(parent, child);
+  return rel !== "" && !rel.startsWith("..") && !path8.isAbsolute(rel);
 }
 function hasGitEntry(dir) {
-  return fs4.existsSync(path7.join(dir, ".git"));
+  return fs4.existsSync(path8.join(dir, ".git"));
 }
 function firstLine(text) {
   return text.split(/\r?\n/, 1)[0].trim();
@@ -4003,12 +4067,20 @@ function statusPaths(porcelain) {
   }
   return paths;
 }
+function leftoverMarkerFiles(check) {
+  const files = check.split(/\r?\n/).flatMap((line) => /^(.+):\d+: leftover conflict marker$/.exec(line)?.[1] ?? []);
+  return [...new Set(files)];
+}
+function settleStatus(record, status) {
+  record.status = status;
+  delete record.repairBase;
+}
 function sameDir(a, b) {
   const real = (p) => {
     try {
       return fs4.realpathSync.native(p);
     } catch {
-      return path7.resolve(p);
+      return path8.resolve(p);
     }
   };
   return real(a) === real(b);
@@ -4042,8 +4114,8 @@ function inactive(reason, repos) {
 }
 function groupPathOf(listed) {
   const slashed = listed.trim().replace(/\\/g, "/");
-  if (path7.posix.isAbsolute(slashed) || path7.win32.isAbsolute(slashed)) return null;
-  const rel = path7.posix.normalize(slashed).replace(/\/+$/, "");
+  if (path8.posix.isAbsolute(slashed) || path8.win32.isAbsolute(slashed)) return null;
+  const rel = path8.posix.normalize(slashed).replace(/\/+$/, "");
   return rel === "" || rel === "." || rel === ".." || rel.startsWith("../") ? null : rel;
 }
 function matchLinks(root, patterns) {
@@ -4059,9 +4131,26 @@ function matchLinks(root, patterns) {
 }
 function segmentMatches(root, base, segment) {
   const under = (name) => base ? `${base}/${name}` : name;
-  if (!/[*?]/.test(segment)) return lexists(path7.join(root, base, segment)) ? [under(segment)] : [];
+  if (!/[*?]/.test(segment)) return lexists(path8.join(root, base, segment)) ? [under(segment)] : [];
   const pattern = new RegExp(`^${segment.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".")}$`);
-  return listDir(path7.join(root, base)).filter((name) => !NEVER_SCANNED.has(name) && pattern.test(name)).map(under);
+  return listDir(path8.join(root, base)).filter((name) => !NEVER_SCANNED.has(name) && pattern.test(name)).map(under);
+}
+function installDirs(root) {
+  const packages = matchLinks(root, workspaceGlobs(root)).map((pkg) => `${pkg}/node_modules`);
+  return ["node_modules", ...packages].filter((dir) => lexists(path8.join(root, dir)));
+}
+function workspaceGlobs(root) {
+  let manifest;
+  try {
+    manifest = JSON.parse(fs4.readFileSync(path8.join(root, "package.json"), "utf8"));
+  } catch {
+    return [];
+  }
+  if (typeof manifest !== "object" || manifest === null || !("workspaces" in manifest)) return [];
+  const { workspaces } = manifest;
+  const listed = typeof workspaces === "object" && workspaces !== null && "packages" in workspaces ? workspaces.packages : workspaces;
+  if (!Array.isArray(listed)) return [];
+  return listed.filter((glob) => typeof glob === "string" && !glob.startsWith("!"));
 }
 var GitWorktreeIsolation = class {
   constructor(deps) {
@@ -4115,7 +4204,7 @@ var GitWorktreeIsolation = class {
   groupPaths(workspaceRoot) {
     const listed = this.deps.config.workspaceRepos;
     if (listed.length === 0) return this.reposDirectlyIn(workspaceRoot);
-    const paths = listed.map(groupPathOf).filter((rel) => rel !== null && hasGitEntry(path7.join(workspaceRoot, rel)));
+    const paths = listed.map(groupPathOf).filter((rel) => rel !== null && hasGitEntry(path8.join(workspaceRoot, rel)));
     return [...new Set(paths)].sort();
   }
   async committedRepos(workspaceRoot, paths) {
@@ -4131,7 +4220,7 @@ var GitWorktreeIsolation = class {
     return status.ok ? status.stdout.trim() !== "" : null;
   }
   reposDirectlyIn(dir) {
-    return this.childDirs(dir).filter((name) => hasGitEntry(path7.join(dir, name)));
+    return this.childDirs(dir).filter((name) => hasGitEntry(path8.join(dir, name)));
   }
   childDirs(dir) {
     try {
@@ -4148,9 +4237,9 @@ var GitWorktreeIsolation = class {
   async nestedRepos(workspaceRoot, toplevel) {
     const found = [];
     const walk = (rel, depth) => {
-      for (const name of this.childDirs(path7.join(workspaceRoot, rel))) {
+      for (const name of this.childDirs(path8.join(workspaceRoot, rel))) {
         const child = rel ? `${rel}/${name}` : name;
-        if (hasGitEntry(path7.join(workspaceRoot, child))) found.push(child);
+        if (hasGitEntry(path8.join(workspaceRoot, child))) found.push(child);
         else if (depth < NESTED_REPO_DEPTH) walk(child, depth + 1);
       }
     };
@@ -4171,7 +4260,7 @@ var GitWorktreeIsolation = class {
       const [meta, file] = entry.split("	");
       if (file !== void 0 && meta.startsWith(`${GITLINK_MODE} `)) paths.add(file);
     }
-    const declared = await this.tryGit(workspaceRoot, ["config", "-z", "-f", path7.join(toplevel, ".gitmodules"), "--get-regexp", "^submodule\\..*\\.path$"]);
+    const declared = await this.tryGit(workspaceRoot, ["config", "-z", "-f", path8.join(toplevel, ".gitmodules"), "--get-regexp", "^submodule\\..*\\.path$"]);
     for (const entry of declared.stdout.split("\0")) {
       const value = entry.split("\n")[1];
       if (value) paths.add(value.replace(/\/+$/, ""));
@@ -4227,7 +4316,7 @@ var GitWorktreeIsolation = class {
   async acceptsWorktree(run, repo) {
     const dir = this.integrationDir(run, repo);
     ensureStateDirIgnored(run.workspaceRoot);
-    fs4.mkdirSync(path7.dirname(dir), { recursive: true });
+    fs4.mkdirSync(path8.dirname(dir), { recursive: true });
     const added = await this.tryGit(repo.root, ["worktree", "add", "-q", "--no-checkout", dir, repo.integrationBranch]);
     await this.removeWorktreeDir(run, repo, dir, []);
     return added.ok;
@@ -4242,12 +4331,12 @@ var GitWorktreeIsolation = class {
     if (isolated.includes(SELF_REPO)) return [];
     const shared = [];
     const walk = (rel) => {
-      for (const name of listDir(path7.join(workspaceRoot, rel))) {
+      for (const name of listDir(path8.join(workspaceRoot, rel))) {
         if (!rel && (name === STATE_DIR || name === ".git")) continue;
         const child = rel ? `${rel}/${name}` : name;
         if (isolated.includes(child)) continue;
         if (isolated.some((p) => p.startsWith(`${child}/`))) walk(child);
-        else if (resolves(path7.join(workspaceRoot, child))) shared.push(child);
+        else if (resolves(path8.join(workspaceRoot, child))) shared.push(child);
       }
     };
     walk("");
@@ -4264,17 +4353,17 @@ var GitWorktreeIsolation = class {
       const copied = [];
       try {
         for (const repo of run.repos) {
-          const worktree = path7.join(dir, repo.path);
+          const worktree = path8.join(dir, repo.path);
           const tip = (await this.git(repo.root, ["rev-parse", repo.integrationBranch])).trim();
-          fs4.mkdirSync(path7.dirname(worktree), { recursive: true });
+          fs4.mkdirSync(path8.dirname(worktree), { recursive: true });
           await this.git(repo.root, ["worktree", "add", "-q", "-B", branch, worktree, tip]);
           record.repos[repo.path] = { worktree, linked: [] };
         }
         run.shared = this.sharedPaths(run.workspaceRoot, run.repos.map((r) => r.path));
         for (const rel of run.shared) {
-          const target = path7.join(dir, rel);
-          fs4.mkdirSync(path7.dirname(target), { recursive: true });
-          if (linkPath(path7.join(run.workspaceRoot, rel), target, this.platform) === "copy") copied.push(rel);
+          const target = path8.join(dir, rel);
+          fs4.mkdirSync(path8.dirname(target), { recursive: true });
+          if (linkPath(path8.join(run.workspaceRoot, rel), target, this.platform) === "copy") copied.push(rel);
         }
         for (const repo of run.repos) {
           const entry = record.repos[repo.path];
@@ -4282,7 +4371,7 @@ var GitWorktreeIsolation = class {
           if (repo.path === SELF_REPO) cwd = inRepo;
           const boot = await this.bootstrap(repo, inRepo);
           entry.linked = boot.linked;
-          copied.push(...boot.copied.map((name) => path7.posix.join(repo.path, name)));
+          copied.push(...boot.copied.map((name) => path8.posix.join(repo.path, name)));
         }
       } catch (err) {
         record.status = "failed";
@@ -4293,6 +4382,53 @@ var GitWorktreeIsolation = class {
       return { cwd, branch, copied };
     });
   }
+  reopen(task, run) {
+    return this.admin(run.workspaceRoot, async () => {
+      const record = run.tasks[task.id];
+      if (record?.status !== "conflict") throw new Error(`Task ${task.order} has no conflict to repair`);
+      let cwd = record.workspace;
+      const repairBase = {};
+      for (const repo of run.repos) {
+        const entry = record.repos[repo.path];
+        if (!entry) continue;
+        if (!fs4.existsSync(entry.worktree)) throw new Error(`The worktree of task ${task.order} is gone: ${entry.worktree}`);
+        if (repo.path === SELF_REPO) cwd = await this.inWorkspacePlace(repo, entry.worktree);
+        if (entry.changed || repo.path === record.conflictRepo) {
+          repairBase[repo.path] = (await this.git(repo.root, ["rev-parse", "--verify", repo.integrationBranch])).trim();
+        }
+      }
+      const files = (record.conflictFiles ?? []).map((file) => record.conflictRepo && record.conflictRepo !== SELF_REPO ? `${record.conflictRepo}/${file}` : file);
+      record.repairs = (record.repairs ?? 0) + 1;
+      record.repairBase = repairBase;
+      record.repairedFiles = [.../* @__PURE__ */ new Set([...record.repairedFiles ?? [], ...files])];
+      record.status = "repairing";
+      return { cwd, branch: record.branch, copied: [] };
+    });
+  }
+  async verifyRepair(task, run) {
+    const record = run.tasks[task.id];
+    if (!record?.repairBase) return { ok: false, reason: "failed", repo: record?.conflictRepo ?? SELF_REPO };
+    for (const repo of run.repos) {
+      const entry = record.repos[repo.path];
+      if (!entry) continue;
+      try {
+        await this.commitWorktree(repo, record, entry);
+      } catch {
+        return { ok: false, reason: "failed", repo: repo.path };
+      }
+    }
+    for (const repo of run.repos) {
+      const base = record.repairBase[repo.path];
+      if (base === void 0) continue;
+      const contains = await this.tryGit(repo.root, ["merge-base", "--is-ancestor", base, record.branch]);
+      if (!contains.ok) return { ok: false, reason: contains.code === 1 ? "not-merged" : "failed", repo: repo.path };
+      const check = await this.tryGit(repo.root, ["-c", "core.quotePath=false", "diff", "--check", base, record.branch]);
+      if (!check.ok && check.code !== 2) return { ok: false, reason: "failed", repo: repo.path };
+      const files = leftoverMarkerFiles(check.stdout);
+      if (files.length > 0) return { ok: false, reason: "conflict-markers", repo: repo.path, files };
+    }
+    return { ok: true };
+  }
   /**
    * The place in a repo's worktree that matches where the workspace sits in
    * the real repo: the worktree itself, or a subdirectory of it when the
@@ -4300,7 +4436,7 @@ var GitWorktreeIsolation = class {
    */
   async inWorkspacePlace(repo, worktree) {
     const prefix = await this.prefixOf(repo);
-    return prefix ? path7.join(worktree, prefix) : worktree;
+    return prefix ? path8.join(worktree, prefix) : worktree;
   }
   async prefixOf(repo) {
     return (await this.git(repo.root, ["rev-parse", "--show-prefix"])).trim();
@@ -4320,6 +4456,7 @@ var GitWorktreeIsolation = class {
       if (!record) return;
       if (opts.keep) {
         if (record.status === "active") record.status = "kept";
+        else if (record.status === "repairing") settleStatus(record, "conflict");
         return;
       }
       await this.removeTask(run, record, { dropRecord: true });
@@ -4339,6 +4476,7 @@ var GitWorktreeIsolation = class {
       for (const record of Object.values(run.tasks)) {
         if (record.status === "active") await this.removeTask(run, record, { dropRecord: true });
         else if (record.status === "merged") await this.removeTask(run, record, { dropRecord: false });
+        else if (record.status === "repairing") settleStatus(record, "conflict");
       }
       await this.removeUnowned(run);
       for (const repo of run.repos) await this.tryGit(repo.root, ["worktree", "prune"]);
@@ -4433,14 +4571,59 @@ var GitWorktreeIsolation = class {
         await this.removeTask(run, record, { dropRecord: record.status !== "merged" });
       }
       await this.removeUnowned(run);
-      if (!opts.keepIntegration) {
-        for (const repo of run.repos) await this.tryGit(repo.root, ["branch", "-D", repo.integrationBranch]);
+      if (opts.integration !== "keep") {
+        for (const repo of run.repos) {
+          if (opts.integration === "delete") await this.tryGit(repo.root, ["branch", "-D", repo.integrationBranch]);
+          else await this.deleteIfMerged(repo.root, repo.integrationBranch);
+        }
         run.tasks = {};
         this.removeIfEmpty(this.runRoot(run));
       }
       for (const repo of run.repos) await this.tryGit(repo.root, ["worktree", "prune"]);
     });
   }
+  sweep(run) {
+    return this.admin(run.workspaceRoot, async () => {
+      const failed = [];
+      for (const repo of run.repos) {
+        if (!await this.sweepRepo(run, repo)) failed.push(repo.path);
+      }
+      if (failed.length > 0) throw new Error(`git failed clearing merged branches of earlier runs in ${failed.join(", ")}`);
+    });
+  }
+  /** False when git failed anywhere; the other branches are still tried. */
+  async sweepRepo(run, repo) {
+    await this.tryGit(repo.root, ["worktree", "prune"]);
+    const worktrees = await this.tryGit(repo.root, ["worktree", "list", "--porcelain"]);
+    const refs = await this.tryGit(repo.root, ["for-each-ref", "--format=%(refname)", "refs/heads/ordewell/"]);
+    if (!worktrees.ok || !refs.ok) return false;
+    const checkedOut = /* @__PURE__ */ new Set();
+    const liveRuns = /* @__PURE__ */ new Set();
+    for (const line of worktrees.stdout.split(/\r?\n/)) {
+      if (line.startsWith("branch refs/heads/")) checkedOut.add(line.slice("branch refs/heads/".length));
+      const runId = line.startsWith("worktree ") ? RUN_WORKTREE.exec(line)?.[1] : void 0;
+      if (runId) liveRuns.add(runId);
+    }
+    let ok = true;
+    for (const ref of refs.stdout.split(/\r?\n/).filter(Boolean)) {
+      const branch = ref.slice("refs/heads/".length);
+      const runId = RUN_BRANCH.exec(branch)?.[1];
+      if (!runId || runId === run.id || liveRuns.has(runId) || checkedOut.has(branch)) continue;
+      if (await this.deleteIfMerged(repo.root, branch) === "failed") ok = false;
+    }
+    return ok;
+  }
+  /**
+   * Delete `branch` only if the repo's checked-out HEAD already contains it —
+   * HEAD, not an upstream: what the user has checked out is what they merged
+   * into. `-d` rather than `-D`, so git also refuses a branch a worktree has
+   * checked out.
+   */
+  async deleteIfMerged(root, branch) {
+    const merged = await this.tryGit(root, ["merge-base", "--is-ancestor", branch, "HEAD"]);
+    if (!merged.ok) return merged.code === 1 ? "kept" : "failed";
+    return (await this.tryGit(root, ["branch", "-d", branch])).ok ? "deleted" : "failed";
+  }
   async drain() {
     try {
       while (this.waiting.length > 0) {
@@ -4493,21 +4676,24 @@ var GitWorktreeIsolation = class {
         return this.stopLanding(record, "failed");
       }
       for (const repo of changed) {
-        const outcome = await this.mergeTask(run, repo, record);
+        const { outcome, files } = await this.mergeTask(run, repo, record);
         if (outcome === "merged") continue;
-        return (await this.settleLanding(run)).length === 0 ? this.stopLanding(record, outcome, repo) : this.stopLanding(record, "failed", repo);
+        return (await this.settleLanding(run)).length === 0 ? this.stopLanding(record, outcome, repo, files) : this.stopLanding(record, "failed", repo);
       }
     }
     delete run.landing;
-    record.status = "merged";
+    settleStatus(record, "merged");
     delete record.conflictRepo;
+    delete record.conflictFiles;
     await this.admin(run.workspaceRoot, () => this.removeTask(run, record, { dropRecord: false })).catch(() => void 0);
     return "merged";
   }
-  stopLanding(record, outcome, repo) {
-    record.status = outcome;
+  stopLanding(record, outcome, repo, files) {
+    settleStatus(record, outcome);
     if (repo) record.conflictRepo = repo.path;
     else delete record.conflictRepo;
+    if (files && files.length > 0) record.conflictFiles = files;
+    else delete record.conflictFiles;
     return outcome;
   }
   /** Merge the task branch into one repo's integration branch. A merge that does not complete is aborted: it is Ordewell's own. */
@@ -4516,13 +4702,13 @@ var GitWorktreeIsolation = class {
     try {
       dir = await this.ensureIntegrationWorktree(run, repo);
     } catch {
-      return "failed";
+      return { outcome: "failed", files: [] };
     }
     const merge = await this.tryGit(dir, ["merge", "--no-ff", "--no-edit", "-m", `Merge task ${record.order}: ${firstLine(record.title)}`, record.branch]);
-    if (merge.ok) return "merged";
-    const conflicted = (await this.unmergedPaths(dir)).length > 0;
+    if (merge.ok) return { outcome: "merged", files: [] };
+    const files = await this.unmergedPaths(dir);
     if (await this.mergeInProgress(dir)) await this.abortMerge(dir);
-    return conflicted ? "conflict" : "failed";
+    return { outcome: files.length > 0 ? "conflict" : "failed", files };
   }
   /**
    * Return every repo of the landing in flight to its recorded tip, then
@@ -4590,15 +4776,15 @@ var GitWorktreeIsolation = class {
     await this.git(entry.worktree, ["commit", "-q", "-m", `ordewell: task ${record.order} ${firstLine(record.title)}`]);
   }
   integrationDir(run, repo) {
-    return path7.join(this.runRoot(run), INTEGRATION_DIR, repo.path);
+    return path8.join(this.runRoot(run), INTEGRATION_DIR, repo.path);
   }
   async ensureIntegrationWorktree(run, repo) {
     return this.admin(run.workspaceRoot, async () => {
       const dir = this.integrationDir(run, repo);
-      if (fs4.existsSync(path7.join(dir, ".git"))) return dir;
+      if (fs4.existsSync(path8.join(dir, ".git"))) return dir;
       await this.tryGit(repo.root, ["worktree", "prune"]);
       ensureStateDirIgnored(run.workspaceRoot);
-      fs4.mkdirSync(path7.dirname(dir), { recursive: true });
+      fs4.mkdirSync(path8.dirname(dir), { recursive: true });
       await this.git(repo.root, ["worktree", "add", "-q", dir, repo.integrationBranch]);
       return dir;
     });
@@ -4633,20 +4819,20 @@ var GitWorktreeIsolation = class {
       return;
     }
     for (const entry of entries) {
-      const target = path7.join(dir, entry.name);
+      const target = path8.join(dir, entry.name);
       if (entry.isSymbolicLink()) this.unlinkIfLink(target);
       else if (entry.isDirectory()) this.unlinkLinksUnder(target);
     }
   }
   /** Task workspaces and branches under this run that no record accounts for. */
   async removeUnowned(run) {
-    const owned = new Set(Object.values(run.tasks).map((r) => path7.resolve(r.workspace)));
+    const owned = new Set(Object.values(run.tasks).map((r) => path8.resolve(r.workspace)));
     const root = this.runRoot(run);
     if (fs4.existsSync(root)) {
       for (const entry of fs4.readdirSync(root)) {
-        const dir = path7.join(root, entry);
-        if (entry === INTEGRATION_DIR || owned.has(path7.resolve(dir))) continue;
-        for (const repo of run.repos) await this.removeWorktreeDir(run, repo, path7.join(dir, repo.path), []);
+        const dir = path8.join(root, entry);
+        if (entry === INTEGRATION_DIR || owned.has(path8.resolve(dir))) continue;
+        for (const repo of run.repos) await this.removeWorktreeDir(run, repo, path8.join(dir, repo.path), []);
         this.removeTaskWorkspace(run, dir);
       }
     }
@@ -4660,14 +4846,18 @@ var GitWorktreeIsolation = class {
     }
   }
   async removeWorktreeDir(run, repo, dir, linked) {
-    for (const name of linked) this.unlinkIfLink(path7.join(dir, name));
+    for (const name of /* @__PURE__ */ new Set([...linked, ...installDirs(dir)])) {
+      const target = path8.join(dir, name);
+      this.unlinkIfLink(target);
+      this.unlinkLinksUnder(target);
+    }
     for (const name of fs4.existsSync(dir) ? fs4.readdirSync(dir) : []) {
-      if (LINKED_ARTIFACTS.has(name) || isEnvFile(name)) this.unlinkIfLink(path7.join(dir, name));
+      if (LINKED_ARTIFACTS.has(name) || isEnvFile(name)) this.unlinkIfLink(path8.join(dir, name));
     }
     await this.tryGit(repo.root, ["worktree", "remove", "--force", dir]);
     if (fs4.existsSync(dir) && isInside(this.runRoot(run), dir)) fs4.rmSync(dir, { recursive: true, force: true });
     await this.tryGit(repo.root, ["worktree", "prune"]);
-    for (let parent = path7.dirname(dir); isInside(this.runRoot(run), parent); parent = path7.dirname(parent)) this.removeIfEmpty(parent);
+    for (let parent = path8.dirname(dir); isInside(this.runRoot(run), parent); parent = path8.dirname(parent)) this.removeIfEmpty(parent);
   }
   unlinkIfLink(target) {
     try {
@@ -4682,14 +4872,14 @@ var GitWorktreeIsolation = class {
     }
   }
   runRoot(run) {
-    return path7.join(run.workspaceRoot, STATE_DIR, "worktrees", run.id);
+    return path8.join(run.workspaceRoot, STATE_DIR, "worktrees", run.id);
   }
   namesFor(run, task) {
     const slug2 = sanitizeSlug(task.title).slice(0, 40).replace(/-+$/, "") || "task";
     let name = `${task.order}-${slug2}`;
     const clash = Object.values(run.tasks).some((r) => r.taskId !== task.id && r.branch === `ordewell/${run.id}/${name}`);
     if (clash) name = `${name}-${sanitizeSlug(task.id) || "x"}`;
-    return { branch: `ordewell/${run.id}/${name}`, dir: path7.join(this.runRoot(run), name) };
+    return { branch: `ordewell/${run.id}/${name}`, dir: path8.join(this.runRoot(run), name) };
   }
   /**
    * Make one repo's worktree runnable: the default artifacts, unless a setup
@@ -4702,16 +4892,26 @@ var GitWorktreeIsolation = class {
     const linked = [];
     const copied = [];
     const link = (name) => {
-      const target = path7.join(cwd, name);
+      const target = path8.join(cwd, name);
       if (lexists(target)) return;
-      fs4.mkdirSync(path7.dirname(target), { recursive: true });
-      if (linkPath(path7.join(repo.root, name), target, this.platform) === "copy") copied.push(name);
+      fs4.mkdirSync(path8.dirname(target), { recursive: true });
+      if (linkPath(path8.join(repo.root, name), target, this.platform) === "copy") copied.push(name);
+      linked.push(name);
+    };
+    const mirror = (name) => {
+      const target = path8.join(cwd, name);
+      if (lexists(target) || !fs4.existsSync(path8.dirname(target))) return;
+      const source = path8.join(repo.root, name);
+      if (!fs4.lstatSync(source).isDirectory()) return link(name);
+      const mirrored = mirrorDir(source, target, { platform: this.platform, from: repo.root, to: cwd });
+      copied.push(...mirrored.map((entry) => path8.join(name, entry)));
       linked.push(name);
     };
     if (!setup) {
       for (const name of fs4.readdirSync(repo.root)) {
-        if (name !== STATE_DIR && (LINKED_ARTIFACTS.has(name) || isEnvFile(name))) link(name);
+        if (name !== STATE_DIR && name !== "node_modules" && (LINKED_ARTIFACTS.has(name) || isEnvFile(name))) link(name);
       }
+      for (const dir of installDirs(repo.root)) mirror(dir);
     }
     for (const name of matchLinks(repo.root, this.deps.config.worktreeLinks)) link(name);
     if (setup) await this.runSetup(setup, repo, cwd);
@@ -5159,6 +5359,7 @@ function researchPhaseBlock(harnessMode) {
 }
 var ISOLATED_PARALLELISM_RULE = "- Each AI task runs in its own git worktree, and its work is merged in afterwards, so tasks that edit the same files can still run in parallel. Never add a dependency just because two tasks touch the same file \u2014 keep dependencies for genuine logical ordering.";
 var OVERLAP_AVOIDANCE_RULE = "- For parallel tasks, specify different target files to avoid merge conflicts.";
+var SHARED_APPEND_FILE_RULE = "- Tasks that run in parallel must not each append to the same shared file (changelogs, registries, index lists) \u2014 give that edit to the final task, or to one task the others depend on.";
 function repoGroupSection(isolated) {
   if (!isolated || isolated.repos.length === 1 && isolated.repos[0] === SELF_REPO) return [];
   return [
@@ -5250,6 +5451,7 @@ function buildConversationBody(goal, context, modelsJson, runners, modeGuide, mo
     "DEPENDENCY & PARALLELISM:",
     "- Independent slices should have NO dependencies \u2014 they run in parallel.",
     "- Only add dependencies when a slice truly depends on artifacts another slice creates.",
+    SHARED_APPEND_FILE_RULE,
     ...variant.isolatedExecution ? [ISOLATED_PARALLELISM_RULE] : [],
     ...repoGroupSection(variant.isolatedExecution),
     "",
@@ -5351,6 +5553,7 @@ function corePlannerPrompt(isolatedExecution) {
     isolatedExecution ? "- Independent vertical slices should have NO dependencies between them \u2014 they can run in parallel." : "- Independent vertical slices (no shared files/modules) should have NO dependencies between them \u2014 they can run in parallel.",
     "- Only add dependencies when the second slice truly depends on artifacts (files, APIs) that the first slice creates.",
     "- Prefer parallelism over serial chains. A plan with 3 independent slices running in parallel is better than 3 sequential tasks.",
+    SHARED_APPEND_FILE_RULE,
     isolatedExecution ? ISOLATED_PARALLELISM_RULE : "- Slices that touch different areas of the codebase are naturally parallel.",
     ...repoGroupSection(isolatedExecution),
     "",
@@ -5628,6 +5831,31 @@ ${task.prompt ?? task.description}`;
     asked
   ].join("\n");
 }
+function buildConflictRepairPrompt(task, conflict, integrationBranch) {
+  const { branch } = conflict;
+  const files = conflict.conflictFiles ?? [];
+  const asked = `What the task was asked to do:
+${task.prompt ?? task.description}`;
+  const resolve6 = "resolve every conflict so that both sides' intent survives: keep the work already integrated and add what the task contributed.";
+  const repos = conflict.repos.filter((repo) => repo !== SELF_REPO);
+  if (repos.length === 0) {
+    return [
+      `Task #${task.order} "${task.title}" passed, but merging its branch \`${branch}\` into \`${integrationBranch}\` conflicted${files.length > 0 ? ` in ${files.join(", ")}` : ""}. None of its work has landed yet.`,
+      `This is the task's own worktree, on \`${branch}\`, with its work committed. Run \`git merge --no-edit ${integrationBranch}\` here and ${resolve6} Never drop either side wholesale, and never abort the merge or reset it away.`,
+      "Build and test the result the way this project does, commit the merge, and only then print the completion marker.",
+      "",
+      asked
+    ].join("\n");
+  }
+  const stoppedIn = conflict.conflictRepo ?? repos[0];
+  return [
+    `Task #${task.order} "${task.title}" passed, but landing its branch \`${branch}\` on \`${integrationBranch}\` conflicted in ${stoppedIn}${files.length > 0 ? ` (${files.join(", ")})` : ""}. A task lands in every repository it changed or in none, so none of its work has landed yet.`,
+    `This is the task's own workspace, with each repository at its usual path on \`${branch}\` and the task's work committed. In each repository the task changed \u2014 ${repos.join(", ")} \u2014 run \`git merge --no-edit ${integrationBranch}\` inside that repository's directory, and ${resolve6} Never drop either side wholesale, and never abort a merge or reset it away.`,
+    "Build and test the result the way this project does, commit the merge in each repository, and only then print the completion marker.",
+    "",
+    asked
+  ].join("\n");
+}
 
 // src/services/PlanRepair.ts
 async function repairLoop(opts) {
@@ -7641,9 +7869,9 @@ ${line}
 };
 
 // src/services/transcriptCapture.ts
-import { readFileSync, readdirSync as readdirSync2, statSync as statSync4, existsSync as existsSync3 } from "fs";
+import { readFileSync as readFileSync2, readdirSync as readdirSync3, statSync as statSync4, existsSync as existsSync4 } from "fs";
 import * as os3 from "os";
-import * as path8 from "path";
+import * as path9 from "path";
 var HomeTranscriptReader = class {
   home;
   constructor(opts = {}) {
@@ -7662,21 +7890,21 @@ var HomeTranscriptReader = class {
 };
 var CLAUDE_PROJECT_NAME_MAX = 200;
 function claudeProjectDirs(home, cwd) {
-  const projects = path8.join(home, ".claude", "projects");
+  const projects = path9.join(home, ".claude", "projects");
   const munged = cwd.replace(/[^a-zA-Z0-9]/g, "-");
   if (munged.length <= CLAUDE_PROJECT_NAME_MAX) {
-    const dir = path8.join(projects, munged);
-    return existsSync3(dir) ? [dir] : [];
+    const dir = path9.join(projects, munged);
+    return existsSync4(dir) ? [dir] : [];
   }
-  if (!existsSync3(projects)) return [];
+  if (!existsSync4(projects)) return [];
   const prefix = `${munged.slice(0, CLAUDE_PROJECT_NAME_MAX)}-`;
-  return readdirSync2(projects).filter((name) => name.startsWith(prefix)).map((name) => path8.join(projects, name));
+  return readdirSync3(projects).filter((name) => name.startsWith(prefix)).map((name) => path9.join(projects, name));
 }
 function claudeFinal(home, query, maxChars) {
   const cutoff = query.startedAt ? Date.parse(query.startedAt) : 0;
-  const candidates = claudeProjectDirs(home, query.cwd).flatMap((dir) => readdirSync2(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path8.join(dir, f))).filter((f) => cutoff ? statSync4(f).mtimeMs >= cutoff - 5e3 : true).sort((a, b) => statSync4(b).mtimeMs - statSync4(a).mtimeMs);
+  const candidates = claudeProjectDirs(home, query.cwd).flatMap((dir) => readdirSync3(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path9.join(dir, f))).filter((f) => cutoff ? statSync4(f).mtimeMs >= cutoff - 5e3 : true).sort((a, b) => statSync4(b).mtimeMs - statSync4(a).mtimeMs);
   for (const file of candidates) {
-    const raw = readFileSync(file, "utf8");
+    const raw = readFileSync2(file, "utf8");
     if (!raw.includes(query.marker)) continue;
     const text = claudeLastAssistant(raw);
     if (text) return clamp(text, maxChars);
@@ -7710,8 +7938,8 @@ async function opencodeFinal(home, query, maxChars) {
   } catch {
     return null;
   }
-  const dbPath = path8.join(home, ".local", "share", "opencode", "opencode.db");
-  if (!existsSync3(dbPath)) return null;
+  const dbPath = path9.join(home, ".local", "share", "opencode", "opencode.db");
+  if (!existsSync4(dbPath)) return null;
   let db;
   try {
     db = new DatabaseSync(dbPath, { open: true });
@@ -7763,8 +7991,8 @@ async function opencodeFinal(home, query, maxChars) {
   }
 }
 function codexFinal(home, query, maxChars) {
-  const root = path8.join(home, ".codex", "sessions");
-  if (!existsSync3(root)) return null;
+  const root = path9.join(home, ".codex", "sessions");
+  if (!existsSync4(root)) return null;
   const cutoff = query.startedAt ? Date.parse(query.startedAt) : 0;
   const files = [];
   const stack = [root];
@@ -7772,12 +8000,12 @@ function codexFinal(home, query, maxChars) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = readdirSync2(dir);
+      entries = readdirSync3(dir);
     } catch {
       continue;
     }
     for (const e of entries) {
-      const full = path8.join(dir, e);
+      const full = path9.join(dir, e);
       let st;
       try {
         st = statSync4(full);
@@ -7796,7 +8024,7 @@ function codexFinal(home, query, maxChars) {
   return null;
 }
 function codexLastAssistant(file, query) {
-  const raw = readFileSync(file, "utf8");
+  const raw = readFileSync2(file, "utf8");
   if (!raw.includes(query.marker)) return null;
   const lines = raw.split("\n").filter((l) => l.trim());
   let sawCwd = false;
@@ -8415,7 +8643,7 @@ var TaskOrchestrator = class {
     if (!this.isolationRun) return null;
     const record = this.isolationRun.tasks[taskId];
     if (!record) return { state: "none" };
-    return taskIsolationOf(record);
+    return taskIsolationOf(record, this.config.conflictRepairAttempts);
   }
   /**
    * The plan's isolation as a surface shows it, for one with no stream to have
@@ -8424,7 +8652,7 @@ var TaskOrchestrator = class {
   isolationView() {
     const run = this.isolationRun;
     if (!run) return null;
-    const tasks = Object.fromEntries(Object.values(run.tasks).map((r) => [r.taskId, taskIsolationOf(r)]));
+    const tasks = Object.fromEntries(Object.values(run.tasks).map((r) => [r.taskId, taskIsolationOf(r, this.config.conflictRepairAttempts)]));
     return { tasks, handoff: handoffOf(run) };
   }
   getAttemptSession(taskId) {
@@ -8460,24 +8688,43 @@ var TaskOrchestrator = class {
   async reviewRunDiff() {
     return this.isolation.reviewDiff(this.requireRun());
   }
-  /** "Merge all": the run's integration branches into whatever the user has checked out, in every repo or none. */
+  /**
+   * "Merge all": the run's integration branches into whatever the user has
+   * checked out, in every repo or none. Once everything merged, the run has
+   * nothing left to hand over, so it is cleared up and forgotten; a branch
+   * the user's HEAD somehow does not contain stays for the next run's sweep.
+   */
   async mergeRun() {
     const run = this.requireRun();
     const result = await this.isolation.mergeIntoCheckedOut(run);
     const branch = integrationBranchNameOf(run);
     const group = run.repos.some((r) => r.path !== SELF_REPO);
-    const { level, message } = describeMergeResult(result, branch, group);
+    const repaired = handoffOf(run).landed.filter((t) => t.repairedFiles?.length);
+    const { level, message } = describeMergeResult(result, branch, group, repaired);
     this.notifications[level](message);
+    if (result.outcome === "merged") await this.clearMergedRun(run);
     return result;
   }
+  async clearMergedRun(run) {
+    try {
+      await this.isolation.discard(run, { integration: "delete-merged" });
+    } catch (err) {
+      this.tell("warn", `Merged, but could not clean up the run's worktrees and branches: ${err instanceof Error ? err.message : String(err)}`);
+      return;
+    }
+    this.forgetRun();
+  }
   /** Worktrees and task branches go; the integration branch and the record stay for review and merge. */
   async cleanupRun() {
-    await this.isolation.discard(this.requireRun(), { keepIntegration: true });
+    await this.isolation.discard(this.requireRun(), { integration: "keep" });
     this.emit("onIsolationChanged");
   }
   /** The run and everything it made go, and the plan forgets it; the next run starts afresh. */
   async discardRun() {
-    await this.isolation.discard(this.requireRun(), { keepIntegration: false });
+    await this.isolation.discard(this.requireRun(), { integration: "delete" });
+    this.forgetRun();
+  }
+  forgetRun() {
     this.isolationRun = null;
     this.resolvers = {};
     this.emit("onIsolationChanged");
@@ -8513,7 +8760,8 @@ var TaskOrchestrator = class {
   }
   loadPlan(tasks, planRunners = ["claude-code"]) {
     this.store.load(tasks, planRunners);
-    this.endAllAttempts("load");
+    const repairs = this.endAllAttempts("load").filter((a) => a.repair && a.worktree);
+    for (const a of repairs) void this.releaseWorktree(a.taskId, { keep: true }, a.integration);
     if (!this.running) this.runMode = null;
     this.blockedStart = null;
     this.planStatus = "approved";
@@ -8571,9 +8819,10 @@ var TaskOrchestrator = class {
     this.running = false;
     this.planStatus = "approved";
     this.terminalRunner.stopAll();
-    const interrupted = [...this.attempts.values()].filter((a) => a.worktree);
-    this.endAllAttempts("stop");
-    for (const a of interrupted) void this.releaseWorktree(a.taskId, { keep: true }, a.integration);
+    for (const a of this.endAllAttempts("stop")) {
+      if (a.repair) this.store.markAwaitingUser(a.taskId);
+      if (a.worktree) void this.releaseWorktree(a.taskId, { keep: true }, a.integration);
+    }
     this.runMode = null;
     this.blockedStart = null;
     this.onHold.clear();
@@ -8589,6 +8838,7 @@ var TaskOrchestrator = class {
     console.error(`[TaskOrchestrator] Task #${task.order} "${task.title}" verdict=${verdict.outcome}`);
     console.error(`[TaskOrchestrator] Runner: ${task.assignedRunner}, Model: ${task.assignedModel?.modelId ?? "default"}`);
     console.error(`[TaskOrchestrator] Prompt preview: ${(task.prompt ?? "").slice(0, 200)}`);
+    if (attempt.repair) return this.settleRepair(task, attempt, verdict);
     const doneToken = `<<<ORDEWELL_DONE_${task.completionMarker}>>>`;
     const summary = await this.output.finalText({ ...attempt, completionMarker: task.completionMarker }, doneToken);
     if (this.attempts.get(taskId) !== attempt) return;
@@ -8609,6 +8859,9 @@ ${summary || "(empty \u2014 no output captured)"}`);
     }
     this.store.setTaskOutputSummary(taskId, summarizeOutput(verdict.reason, summary));
     this.logAndArchive(task, verdict);
+    await this.afterVerdict();
+  }
+  async afterVerdict() {
     this.emit("onTaskChanged");
     if (!this.running) {
       if (this.attempts.size === 0) {
@@ -8621,6 +8874,71 @@ ${summary || "(empty \u2014 no output captured)"}`);
     }
     await this.tick();
   }
+  /**
+   * A repair's verdict decides only whether its work may try to land. It never
+   * replaces the verdict the task's own work earned, and a repair that does not
+   * land leaves the task waiting on the user — never a failed task, so never a
+   * halted run.
+   */
+  async settleRepair(task, attempt, verdict) {
+    const landed = verdict.outcome === "pass" ? await this.landRepair(task, attempt) : null;
+    if (this.attempts.get(task.id) !== attempt) return;
+    this.endAttempt(task.id, "verdict");
+    if (!landed) await this.unrepaired(task, `did not finish (${verdict.reason})`);
+    else if (!landed.evidence.ok) await this.unrepaired(task, this.describeEvidence(landed.evidence));
+    else if (landed.outcome === "merged") await this.landedRepair(task, verdict);
+    else this.landUnmerged(task, landed.outcome);
+    await this.afterVerdict();
+  }
+  /**
+   * Evidence before the queue: the repair's work is committed and checked, and
+   * only then merged, through the same serialized landing as any other task —
+   * so a repair the tip has moved past again is a fresh conflict, not a pass.
+   */
+  async landRepair(task, attempt) {
+    const run = this.isolationRun;
+    let evidence = { ok: false, reason: "failed", repo: SELF_REPO };
+    if (!run) return { evidence, outcome: "failed" };
+    attempt.phase = "integrating";
+    attempt.integration = (async () => {
+      evidence = await this.isolation.verifyRepair(task, run).catch(() => ({ ok: false, reason: "failed", repo: run.tasks[task.id]?.conflictRepo ?? SELF_REPO }));
+      if (evidence.ok) return this.integrateWork(task);
+      await this.releaseWorktree(task.id, { keep: true });
+      return "conflict";
+    })();
+    const outcome = await attempt.integration;
+    return { evidence, outcome };
+  }
+  async landedRepair(task, verdict) {
+    const files = this.isolationRun?.tasks[task.id]?.repairedFiles ?? [];
+    this.store.markCompleted(task.id);
+    this.store.unblockDependents(task.id);
+    this.logAndArchive(task, task.verdict ?? verdict);
+    this.tell("info", `Task "${task.title}" landed after repairing a conflict${files.length > 0 ? ` in ${capConflictFiles(files)}` : ""}.`);
+    await this.landResolved(task.id);
+  }
+  /** A repair that did not land leaves the task as its conflict did: waiting on the user, worktree and refs kept. */
+  async unrepaired(task, why) {
+    await this.releaseWorktree(task.id, { keep: true });
+    this.store.markAwaitingUser(task.id);
+    const group = this.isolationRun?.repos.some((r) => r.path !== SELF_REPO);
+    this.tell("warn", `The conflict repair of task "${task.title}" ${why}, so it did not land. Its ${group ? "worktrees are" : "worktree is"} kept \u2014 resolve it by hand and mark it complete, retry it, or resolve it as a task.`);
+  }
+  describeEvidence(evidence) {
+    const run = this.isolationRun;
+    const inRepo = evidence.repo !== SELF_REPO ? ` in ${evidence.repo}` : "";
+    const branch = run ? integrationBranchNameOf(run) : "the integration branch";
+    switch (evidence.reason) {
+      case "not-merged":
+        return `finished, but its branch${inRepo} does not contain ${branch}`;
+      case "conflict-markers": {
+        const files = (evidence.files ?? []).map((file) => evidence.repo !== SELF_REPO ? `${evidence.repo}/${file}` : file);
+        return `finished, but left conflict markers in ${capConflictFiles(files)}`;
+      }
+      case "failed":
+        return `finished, but git could not check its work${inRepo}`;
+    }
+  }
   /**
    * Merge a passed attempt's worktree. The attempt stays live while it waits on
    * the module's merge queue, so a cancel, retry or stop in that window still
@@ -8654,11 +8972,25 @@ ${summary || "(empty \u2014 no output captured)"}`);
   }
   landUnmerged(task, landing) {
     const branch = this.isolationRun ? integrationBranchNameOf(this.isolationRun) : "the integration branch";
-    const repo = this.isolationRun?.tasks[task.id]?.conflictRepo;
-    const inRepo = repo && repo !== SELF_REPO ? repo : null;
+    const record = this.isolationRun?.tasks[task.id];
+    const inRepo = record?.conflictRepo && record.conflictRepo !== SELF_REPO ? record.conflictRepo : null;
     if (landing === "conflict") {
+      const repair = this.nextRepair(task.id);
       this.store.markAwaitingUser(task.id);
-      this.notifications.warn(inRepo ? `Task "${task.title}" passed, but landing it on ${branch} conflicted in ${inRepo}, so none of it landed. Its worktrees are kept \u2014 resolve it by hand, retry it, or resolve it as a task.` : `Task "${task.title}" passed, but merging it into ${branch} conflicted. Its worktree is kept \u2014 resolve it by hand, retry it, or resolve it as a task.`);
+      const files = record?.conflictFiles?.length ? ` (${capConflictFiles(record.conflictFiles)})` : "";
+      const conflicted = inRepo ? `Task "${task.title}" passed, but landing it on ${branch} conflicted in ${inRepo}${files}, so none of it landed.` : `Task "${task.title}" passed, but merging it into ${branch} conflicted${files}.`;
+      if (repair) {
+        this.notifications.warn(conflicted);
+        if (this.attempts.size < this.config.maxParallelSessions) void this.startTask(task);
+        else {
+          this.store.markPending(task.id);
+          this.tell("info", `Task "${task.title}" is repaired once a slot is free.`);
+        }
+        return;
+      }
+      this.notifications.warn(`${conflicted} ${inRepo ? "Its worktrees are" : "Its worktree is"} kept \u2014 resolve it by hand and mark it complete, retry it, or resolve it as a task.`);
+      const whyNot = this.noRepairReason(task);
+      if (whyNot) this.tell("info", whyNot);
     } else {
       this.store.markFailed(task.id);
       this.running = false;
@@ -8666,6 +8998,19 @@ ${summary || "(empty \u2014 no output captured)"}`);
       this.notifications.error(inRepo ? `Task "${task.title}" passed, but git could not integrate its work in ${inRepo}, so none of it landed. Its worktrees are kept for inspection.` : `Task "${task.title}" passed, but git could not integrate its work. Its worktree is kept for inspection.`);
     }
   }
+  /** The repair a conflicted task is owed next; null when repair is off, used up, or there is no isolated run to repair it in. */
+  nextRepair(taskId) {
+    const record = this.runMode === "isolated" ? this.isolationRun?.tasks[taskId] : void 0;
+    const limit = this.config.conflictRepairAttempts;
+    const spent = record?.repairs ?? 0;
+    return record?.status === "conflict" && spent < limit ? { n: spent + 1, limit } : null;
+  }
+  noRepairReason(task) {
+    const limit = this.config.conflictRepairAttempts;
+    if (limit === 0) return `Conflict repair is off (conflictRepairAttempts is 0), so task "${task.title}" waits for you.`;
+    const spent = this.isolationRun?.tasks[task.id]?.repairs ?? 0;
+    return spent >= limit ? `Task "${task.title}" has had ${spent} of its ${limit} conflict repairs, so its conflict waits for you.` : null;
+  }
   /**
    * Mark which added task resolves which conflict. The resolver merges the
    * conflicted task's branch by hand in its own worktree; once that lands, the
@@ -8955,6 +9300,7 @@ ${summary || "(empty \u2014 no output captured)"}`);
       cwd: null,
       worktree: false,
       integration: null,
+      repair: this.nextRepair(task.id),
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.spawnCounts.set(task.id, attempt.attempt);
@@ -8965,12 +9311,13 @@ ${summary || "(empty \u2014 no output captured)"}`);
       const cwd = await this.resolveAttemptCwd(task, attempt);
       attempt.cwd = cwd;
       if (this.attempts.get(task.id) !== attempt) {
-        if (attempt.worktree && !this.attempts.has(task.id)) await this.releaseWorktree(task.id, { keep: false });
-        return this.abandonSpawn(task);
+        if (attempt.worktree && !this.attempts.has(task.id)) await this.releaseWorktree(task.id, { keep: attempt.repair !== null });
+        return this.abandonSpawn(task, attempt);
       }
-      const finalPrompt = composeAugmentedPrompt(task, this.store.planTasks, {
+      const finalPrompt = composeAugmentedPrompt(attempt.repair ? { ...task, prompt: this.repairPrompt(task) } : task, this.store.planTasks, {
         planMapEnabled: this.config.planMapEnabled,
-        tddEnabled: this.tddEnabled()
+        // A merge to resolve is not new behaviour to drive test-first.
+        tddEnabled: !attempt.repair && this.tddEnabled()
       });
       const session = await this.terminalRunner.spawn({
         taskId: task.id,
@@ -8985,16 +9332,26 @@ ${summary || "(empty \u2014 no output captured)"}`);
         order: task.order,
         title: task.title
       });
-      if (this.attempts.get(task.id) !== attempt) return this.abandonSpawn(task, session);
+      if (this.attempts.get(task.id) !== attempt) return this.abandonSpawn(task, attempt, session);
       attempt.phase = "running";
       attempt.session = session;
       this.output.attach(task.id, session);
       this.verifier.watch(task, session);
       this.emit("onTaskChanged");
-      this.notifications.info(`Task "${task.title}" started (${attempt.runner})`);
+      if (attempt.repair) {
+        const group = this.isolationRun?.repos.some((r) => r.path !== SELF_REPO);
+        this.tell("info", `Repairing the conflict of task "${task.title}" in its own ${group ? "worktrees" : "worktree"} (repair ${attempt.repair.n} of ${attempt.repair.limit}).`);
+      } else {
+        this.notifications.info(`Task "${task.title}" started (${attempt.runner})`);
+      }
     } catch (err) {
-      if (this.attempts.get(task.id) !== attempt) return this.abandonSpawn(task);
+      if (this.attempts.get(task.id) !== attempt) return this.abandonSpawn(task, attempt);
       this.endAttempt(task.id, "spawn-failed");
+      if (attempt.repair) {
+        await this.unrepaired(task, `could not start: ${err instanceof Error ? err.message : String(err)}`);
+        this.emit("onTaskChanged");
+        return this.tick();
+      }
       await this.releaseWorktree(task.id, { keep: false });
       this.store.markPending(task.id);
       this.onHold.add(task.id);
@@ -9008,17 +9365,35 @@ ${summary || "(empty \u2014 no output captured)"}`);
    * and take back the claim it made. Only the claim — whatever ended the
    * attempt may have decided the task since (mark complete, cancel, retry).
    */
-  abandonSpawn(task, session) {
+  abandonSpawn(task, attempt, session) {
     session?.kill();
     if (this.attempts.has(task.id) || this.store.get(task.id)?.status !== "in_progress") return;
-    this.store.markPending(task.id);
+    if (attempt.repair) this.store.markAwaitingUser(task.id);
+    else this.store.markPending(task.id);
     this.emit("onTaskChanged");
   }
+  repairPrompt(task) {
+    const run = this.requireRun();
+    const record = run.tasks[task.id];
+    const conflict = {
+      branch: record?.branch ?? "",
+      repos: Object.keys(record?.repairBase ?? {}),
+      ...record?.conflictRepo ? { conflictRepo: record.conflictRepo } : {},
+      ...record?.conflictFiles ? { conflictFiles: record.conflictFiles } : {}
+    };
+    return buildConflictRepairPrompt(task, conflict, integrationBranchNameOf(run));
+  }
   /**
    * The one place an attempt's working directory is decided. Async so a
    * per-attempt workspace (worktree isolation, #12) can be prepared here.
    */
   async resolveAttemptCwd(task, attempt) {
+    if (attempt.repair && this.isolationRun) {
+      const { cwd: cwd2 } = await this.isolation.reopen(task, this.isolationRun);
+      attempt.worktree = true;
+      this.emit("onIsolationChanged");
+      return cwd2;
+    }
     if (this.runMode !== "isolated" || !this.isolationRun) {
       await this.releaseWorktree(task.id, { keep: false });
       return this.workspaceRootFn();
@@ -9106,8 +9481,18 @@ ${summary || "(empty \u2014 no output captured)"}`);
       }
     }
     this.runMode = "isolated";
+    await this.sweep();
     return true;
   }
+  /** What earlier runs left merged in the group goes; a failure here is worth a word, never a stopped run. */
+  async sweep() {
+    if (!this.isolationRun) return;
+    try {
+      await this.isolation.sweep(this.isolationRun);
+    } catch (err) {
+      this.tell("warn", `Could not clear merged branches of earlier runs: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
   /**
    * The plan's run carries on while anything has landed on its integration
    * branch: a resumed plan's dependents must start from a tip that holds their
@@ -9120,14 +9505,14 @@ ${summary || "(empty \u2014 no output captured)"}`);
   /**
    * A run with nothing landed holds only superseded attempts, so it goes whole.
    * One that cannot be continued for another reason — it ran from a different
-   * workspace path — keeps its integration branch: only the user gives landed
-   * work up.
+   * workspace path — keeps its integration branch in each repo that has not
+   * merged it: only the user gives landed work up.
    */
   async mintRun(root) {
     const previous = this.isolationRun;
     if (previous) {
       const landed = Object.values(previous.tasks).some((r) => r.status === "merged");
-      await this.isolation.discard(previous, { keepIntegration: landed }).catch(() => void 0);
+      await this.isolation.discard(previous, { integration: landed ? "delete-merged" : "delete" }).catch(() => void 0);
       this.isolationRun = null;
     }
     this.isolationRun = await this.isolation.startRun(root);
@@ -9192,9 +9577,11 @@ ${summary || "(empty \u2014 no output captured)"}`);
     return attempt;
   }
   endAllAttempts(reason) {
-    for (const taskId of [...this.attempts.keys()]) this.endAttempt(taskId, reason);
+    const ended = [...this.attempts.values()];
+    for (const { taskId } of ended) this.endAttempt(taskId, reason);
     this.verifier.reset();
     if (reason === "load") this.output.reset();
+    return ended;
   }
 };
 
@@ -9324,7 +9711,7 @@ ${errors.map((e) => `- ${e}`).join("\n")}`
 };
 
 // src/services/ModelDiscovery.ts
-import * as path11 from "path";
+import * as path12 from "path";
 import { exec as exec3, spawn } from "child_process";
 import { promisify as promisify3 } from "util";
 import * as fsSync3 from "fs";
@@ -9332,17 +9719,17 @@ import * as osMod from "os";
 
 // src/utils/globalDataDir.ts
 import * as fs5 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 import * as os4 from "os";
 function globalDataDir() {
-  return path9.join(os4.homedir(), ".ordewell");
+  return path10.join(os4.homedir(), ".ordewell");
 }
 function copyDirSync(src, dest) {
   fs5.mkdirSync(dest, { recursive: true });
   const entries = fs5.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path9.join(src, entry.name);
-    const destPath = path9.join(dest, entry.name);
+    const srcPath = path10.join(src, entry.name);
+    const destPath = path10.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirSync(srcPath, destPath);
     } else {
@@ -9354,12 +9741,12 @@ var migrated = false;
 function migrateOldConfigDir() {
   if (migrated) return;
   migrated = true;
-  const oldDir = path9.join(os4.homedir(), ".config", "ordewell");
+  const oldDir = path10.join(os4.homedir(), ".config", "ordewell");
   if (!fs5.existsSync(oldDir)) return;
   const newDir = globalDataDir();
   const liftFile = (name) => {
-    const oldFile = path9.join(oldDir, name);
-    const newFile = path9.join(newDir, name);
+    const oldFile = path10.join(oldDir, name);
+    const newFile = path10.join(newDir, name);
     if (fs5.existsSync(oldFile) && !fs5.existsSync(newFile)) {
       fs5.mkdirSync(newDir, { recursive: true });
       fs5.copyFileSync(oldFile, newFile);
@@ -9367,8 +9754,8 @@ function migrateOldConfigDir() {
   };
   liftFile("settings.json");
   liftFile(".env");
-  const oldPlugins = path9.join(oldDir, "plugins");
-  const newPlugins = path9.join(newDir, "plugins");
+  const oldPlugins = path10.join(oldDir, "plugins");
+  const newPlugins = path10.join(newDir, "plugins");
   if (fs5.existsSync(oldPlugins) && !fs5.existsSync(newPlugins)) {
     copyDirSync(oldPlugins, newPlugins);
   }
@@ -9376,7 +9763,7 @@ function migrateOldConfigDir() {
 
 // src/utils/launch.ts
 import * as fsSync2 from "fs";
-import * as path10 from "path";
+import * as path11 from "path";
 
 // src/utils/shell.ts
 var ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]|\x1b\][^\x07]*\x07|\x1b[()][AB012]|\r/g;
@@ -9405,7 +9792,7 @@ var CMD_EXE_MAX_COMMAND_LINE = 8191;
 var WINDOWS_MAX_COMMAND_LINE = 32767;
 function defaultPowerShell() {
   const root = process.env.SystemRoot || process.env.windir;
-  return root ? path10.win32.join(root, "System32", "WindowsPowerShell", "v1.0", "powershell.exe") : "powershell.exe";
+  return root ? path11.win32.join(root, "System32", "WindowsPowerShell", "v1.0", "powershell.exe") : "powershell.exe";
 }
 var POWERSHELL_FLAGS = ["-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File"];
 var CommandLineTooLongError = class extends Error {
@@ -9457,7 +9844,7 @@ Searched: ${searchedPath || "(empty PATH)"}`);
 };
 function isResolvableOnPosixPath(command, PATH, exists) {
   if (command.includes("/")) return exists(command);
-  return PATH.split(path10.delimiter).map((d) => d.trim()).filter(Boolean).some((dir) => exists(path10.join(dir, command)));
+  return PATH.split(path11.delimiter).map((d) => d.trim()).filter(Boolean).some((dir) => exists(path11.join(dir, command)));
 }
 function isExecutableResolved(command, plan, PATH, deps = {}) {
   if ((deps.platform ?? process.platform) === "win32") return plan.file !== command;
@@ -9497,9 +9884,9 @@ function cmdArgs(line) {
   return ["/d", "/s", "/c", `"${line}"`];
 }
 function candidateExtensions(command, pathExt) {
-  const declared = pathExt.split(path10.win32.delimiter).map((e) => e.trim().toLowerCase()).filter(Boolean);
+  const declared = pathExt.split(path11.win32.delimiter).map((e) => e.trim().toLowerCase()).filter(Boolean);
   const known = /* @__PURE__ */ new Set([...DIRECT_EXTENSIONS, ...BATCH_EXTENSIONS, ...POWERSHELL_EXTENSIONS, ...declared]);
-  const ext = path10.win32.extname(command).toLowerCase();
+  const ext = path11.win32.extname(command).toLowerCase();
   if (ext && known.has(ext)) {
     const route = BATCH_EXTENSIONS.includes(ext) ? "cmd" : POWERSHELL_EXTENSIONS.includes(ext) ? "powershell" : "direct";
     return { direct: [], cmd: [], powershell: [], [route]: [""] };
@@ -9520,13 +9907,13 @@ async function findWindowsExecutables(command, deps) {
   const exists = deps.exists ?? defaultExists2;
   const pathExt = (deps.pathExt ?? (() => process.env.PATHEXT ?? ""))();
   const byRoute = candidateExtensions(command, pathExt);
-  const dirs = path10.win32.basename(command) !== command ? [path10.win32.dirname(path10.win32.resolve(command))] : (await (deps.resolvePath ?? augmentedPath)() || "").split(path10.win32.delimiter).map((d) => d.trim().replace(/^"|"$/g, "")).filter(Boolean);
-  const base = path10.win32.basename(command);
+  const dirs = path11.win32.basename(command) !== command ? [path11.win32.dirname(path11.win32.resolve(command))] : (await (deps.resolvePath ?? augmentedPath)() || "").split(path11.win32.delimiter).map((d) => d.trim().replace(/^"|"$/g, "")).filter(Boolean);
+  const base = path11.win32.basename(command);
   const found = [];
   for (const route of ROUTES) {
     outer: for (const ext of byRoute[route]) {
       for (const dir of dirs) {
-        const candidate = path10.win32.join(dir, `${base}${ext}`);
+        const candidate = path11.win32.join(dir, `${base}${ext}`);
         if (exists(candidate)) {
           found.push({ file: candidate, route });
           break outer;
@@ -9621,7 +10008,7 @@ var defaultAppServerClient = async (command, args, options) => {
   const PATH = await augmentedPath();
   const launch = await planDirectLaunch(command, args).catch(() => null);
   if (!launch) return null;
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     let child;
     try {
       child = spawn(launch.file, launch.args, {
@@ -9630,7 +10017,7 @@ var defaultAppServerClient = async (command, args, options) => {
         windowsVerbatimArguments: launch.verbatim
       });
     } catch {
-      resolve5(null);
+      resolve6(null);
       return;
     }
     let settled = false;
@@ -9639,7 +10026,7 @@ var defaultAppServerClient = async (command, args, options) => {
       settled = true;
       clearTimeout(timer);
       killTree(child);
-      resolve5(value);
+      resolve6(value);
     };
     const timer = setTimeout(() => finish(null), options?.timeout ?? 2e4);
     child.on("error", () => finish(null));
@@ -9706,7 +10093,7 @@ function geminiDiscoveryCacheKey(apiKey) {
   return {
     key: `gemini-models:${hash}`,
     dir,
-    file: path11.join(dir, `gemini_models_${hash}.json`)
+    file: path12.join(dir, `gemini_models_${hash}.json`)
   };
 }
 function readGeminiCache(apiKey) {
@@ -10230,7 +10617,7 @@ var ModelDiscovery = class {
 
 // src/services/ModelCatalog.ts
 import * as fs6 from "fs";
-import * as path12 from "path";
+import * as path13 from "path";
 var CACHE_KEY = "model-catalog";
 var CACHE_TTL_MS = 60 * 60 * 1e3;
 function storageKey(baseUrl) {
@@ -10282,7 +10669,7 @@ var ModelCatalog = class {
       const url = (baseUrl || "https://openrouter.ai/api/v1").replace(/\/+$/, "");
       const key = storageKey(url);
       const cacheDir = globalCacheDir();
-      const cacheFile = path12.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
+      const cacheFile = path13.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
       if (fs6.existsSync(cacheFile)) fs6.rmSync(cacheFile);
     } catch {
     }
@@ -10290,7 +10677,7 @@ var ModelCatalog = class {
   static readCache(key) {
     try {
       const cacheDir = globalCacheDir();
-      const cacheFile = path12.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
+      const cacheFile = path13.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
       if (!fs6.existsSync(cacheFile)) return null;
       const raw = fs6.readFileSync(cacheFile, "utf8");
       const data = JSON.parse(raw);
@@ -10304,7 +10691,7 @@ var ModelCatalog = class {
     try {
       const cacheDir = globalCacheDir();
       fs6.mkdirSync(cacheDir, { recursive: true });
-      const cacheFile = path12.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
+      const cacheFile = path13.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
       fs6.writeFileSync(
         cacheFile,
         JSON.stringify({ models, cachedAt: Date.now() }, null, 2)
@@ -10688,7 +11075,8 @@ var ORDEWELL_SETTABLE_ENV = [
   "ORDEWELL_SUBAGENT_MODEL",
   "ORDEWELL_PLANNER_EFFORT",
   "ORDEWELL_RESEARCH_ENABLED",
-  "ORDEWELL_MAX_PARALLEL"
+  "ORDEWELL_MAX_PARALLEL",
+  "ORDEWELL_CONFLICT_REPAIR_ATTEMPTS"
 ];
 var SETTINGS_ENV_REFUSED = [
   // Approval posture and pre-approved scope.
@@ -10745,7 +11133,7 @@ import { spawn as nodeSpawn } from "child_process";
 
 // src/utils/workspace.ts
 import * as fs7 from "fs";
-import * as path13 from "path";
+import * as path14 from "path";
 var WorkspaceNotFoundError = class extends Error {
   constructor(workspace) {
     super(`Workspace "${workspace}" does not exist.`);
@@ -10801,7 +11189,7 @@ function assertWorkspaceIsProject(workspace, deps = {}) {
     throw new WorkspaceNotAProjectError(workspace);
   }
   const hasMarker = [...PROJECT_MARKER_DIRS, ...PROJECT_MARKER_FILES].some(
-    (marker2) => exists(path13.join(resolved, marker2))
+    (marker2) => exists(path14.join(resolved, marker2))
   );
   if (!hasMarker) throw new WorkspaceNotAProjectError(workspace);
 }
@@ -10869,8 +11257,8 @@ var StdioAgentAdapter = class {
   }
   async start(opts) {
     assertWorkspaceExists(opts.cwd, { isDirectory: this.deps.isDirectory });
-    this.processEnded = new Promise((resolve5) => {
-      this.markEnded = resolve5;
+    this.processEnded = new Promise((resolve6) => {
+      this.markEnded = resolve6;
     });
     const spec = this.spawnSpec(opts);
     const resolvePath = this.deps.resolvePath ?? augmentedPath;
@@ -10921,7 +11309,7 @@ ${err.message}`).slice(-STDERR_TAIL_CHARS);
       onEvent({ type: "error", message: this.exitMessage() });
       return;
     }
-    await new Promise((resolve5) => {
+    await new Promise((resolve6) => {
       let settled = false;
       const finish = () => {
         if (settled) return;
@@ -10932,7 +11320,7 @@ ${err.message}`).slice(-STDERR_TAIL_CHARS);
         signal?.removeEventListener("abort", onAbort);
         this.process?.removeListener("exit", onExit);
         this.process?.removeListener("error", onExit);
-        resolve5();
+        resolve6();
       };
       const emit = (event) => {
         onEvent(event);
@@ -11147,14 +11535,14 @@ function codexSandboxUnavailableMessage() {
   ].join("\n");
 }
 function runProbe(deps, cwd, env, flags) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     let output = "";
     let settled = false;
     const finish = (code) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve5({ code, output });
+      resolve6({ code, output });
     };
     const timer = setTimeout(() => finish(null), PROBE_TIMEOUT_MS);
     timer.unref?.();
@@ -11237,8 +11625,8 @@ var CodexAdapter = class extends StdioAgentAdapter {
   async handshake(opts) {
     this.sandbox = await probeCodexSandbox(this.deps, opts.cwd, this.spawnEnv);
     if (this.sandbox === "unavailable") throw new Error(codexSandboxUnavailableMessage());
-    const ready = new Promise((resolve5) => {
-      this.settleHandshake = resolve5;
+    const ready = new Promise((resolve6) => {
+      this.settleHandshake = resolve6;
     });
     this.writeLine({
       jsonrpc: "2.0",
@@ -11251,8 +11639,8 @@ var CodexAdapter = class extends StdioAgentAdapter {
       // A binary that rejects `app-server` outright dies immediately; waiting
       // out the timeout would turn a one-line diagnostic into a 30s stall.
       this.processEnded.then(() => false),
-      new Promise((resolve5) => {
-        const t = setTimeout(() => resolve5(false), HANDSHAKE_TIMEOUT_MS);
+      new Promise((resolve6) => {
+        const t = setTimeout(() => resolve6(false), HANDSHAKE_TIMEOUT_MS);
         t.unref?.();
       })
     ]);
@@ -11529,12 +11917,12 @@ function describeError(err) {
   return lines.join(": ");
 }
 function delay(ms, signal) {
-  return new Promise((resolve5) => {
-    const timer = setTimeout(resolve5, ms);
+  return new Promise((resolve6) => {
+    const timer = setTimeout(resolve6, ms);
     timer.unref?.();
     signal?.addEventListener("abort", () => {
       clearTimeout(timer);
-      resolve5();
+      resolve6();
     }, { once: true });
   });
 }
@@ -11573,12 +11961,12 @@ var OpenCodeAdapter = class {
       cwd: opts.cwd,
       windowsVerbatimArguments: launch.verbatim
     });
-    const banner = new Promise((resolve5) => {
+    const banner = new Promise((resolve6) => {
       let seen = "";
       const scan = (chunk) => {
         seen += chunk.toString();
         const match = seen.match(/https?:\/\/[^\s]+/);
-        if (match) resolve5(match[0].replace(/[.,)]$/, ""));
+        if (match) resolve6(match[0].replace(/[.,)]$/, ""));
       };
       this.process.stdout?.on("data", scan);
       this.process.stderr?.on("data", (chunk) => {
@@ -11587,15 +11975,15 @@ var OpenCodeAdapter = class {
       });
       this.process.on("exit", () => {
         this.exited = true;
-        resolve5(null);
+        resolve6(null);
       });
       this.process.on("error", (err) => {
         this.exited = true;
         this.stderrTail = (this.stderrTail + `
 ${err.message}`).slice(-STDERR_TAIL_CHARS2);
-        resolve5(null);
+        resolve6(null);
       });
-      const timer = setTimeout(() => resolve5(null), SERVER_READY_TIMEOUT_MS);
+      const timer = setTimeout(() => resolve6(null), SERVER_READY_TIMEOUT_MS);
       timer.unref?.();
     });
     this.baseUrl = await banner;
@@ -11628,8 +12016,8 @@ ${this.stderrTail.trim()}` : ""}`);
     const streamAbort = new AbortController();
     let connected = () => {
     };
-    const streamReady = new Promise((resolve5) => {
-      connected = resolve5;
+    const streamReady = new Promise((resolve6) => {
+      connected = resolve6;
     });
     const live = this.streamEvents(
       streamAbort.signal,
@@ -11833,14 +12221,14 @@ ${part.text}` : part.text });
       }
     }
   }
-  async json(method, path22, body, signal) {
-    const response = await this.deps.fetch(`${this.baseUrl}${path22}`, {
+  async json(method, path23, body, signal) {
+    const response = await this.deps.fetch(`${this.baseUrl}${path23}`, {
       method,
       headers: { "content-type": "application/json" },
       ...body === void 0 ? {} : { body: JSON.stringify(body) },
       ...signal ? { signal } : {}
     });
-    if (!response.ok) throw new Error(`${method} ${path22} failed: ${response.status} ${response.statusText}`);
+    if (!response.ok) throw new Error(`${method} ${path23} failed: ${response.status} ${response.statusText}`);
     return await response.json().catch(() => null);
   }
   nativeSessionId() {
@@ -12509,33 +12897,9 @@ var PlannerConversation = class {
       if (m.role !== "user" || index === 0) return [];
       const line = m.content.split("\n")[0];
       const preview = line.length > REWIND_PREVIEW_WIDTH ? `${line.slice(0, REWIND_PREVIEW_WIDTH - 1)}\u2026` : line;
-      return [{ index, preview, timestamp: m.timestamp }];
+      return [{ index, preview, content: m.content, timestamp: m.timestamp }];
     });
   }
-  /**
-   * Cut the dialogue back to just before the user message at `index` (a
-   * position in the transcript), discarding it and everything after. The task
-   * list is the host's and rides along untouched — rewinding moves where the
-   * conversation resumes, not what the plan is. The planner's research trace
-   * goes back to the same point, by time: its entries carry no link to the
-   * message that caused them.
-   */
-  rewind(index) {
-    this.assertIdle("rewind the conversation");
-    const plan = this.requirePlan();
-    if (!this.rewindTargets().some((t) => t.index === index)) {
-      if (index > 0) throw new ConversationEditError(`No user message at position ${index} to rewind to.`);
-      throw new ConversationEditError(this.transcript[0]?.kind === "compaction" ? "The conversation was condensed there \u2014 a rewind cannot reach back past the summary." : "The first message is the goal \u2014 start a new session to change it.");
-    }
-    const cutoff = this.transcript[index].timestamp;
-    const rewound = this.host.mutate(() => {
-      plan.conversationHistory = this.transcript.slice(0, index);
-      plan.researchLog = (plan.researchLog ?? []).filter((e) => e.timestamp < cutoff);
-      return true;
-    }, () => this.host.broadcastPlan());
-    this.reset();
-    return rewound;
-  }
   /**
    * Replace the transcript with a summary of it, keeping the last two
    * exchanges as they were, and drop the live context so the next message
@@ -12611,6 +12975,28 @@ var PlannerConversation = class {
       researchLog: plan?.researchLog ?? []
     });
   }
+  /**
+   * A copy of the dialogue as it stood just before the user message at
+   * `index` (a position from {@link rewindTargets}) — what a rewind forks
+   * from — plus that message's full text, for a surface to offer back. This
+   * conversation is not touched. The research trace is cut at the same point
+   * by time: its entries carry no link to the message that caused them.
+   */
+  cloneBefore(index) {
+    this.assertIdle("rewind the conversation");
+    if (!this.rewindTargets().some((t) => t.index === index)) {
+      if (index > 0) throw new ConversationEditError(`No user message at position ${index} to rewind to.`);
+      throw new ConversationEditError(this.transcript[0]?.kind === "compaction" ? "The conversation was condensed there \u2014 a rewind cannot reach back past the summary." : "The first message is the goal \u2014 start a new session to change it.");
+    }
+    const { content: rewoundMessage, timestamp: cutoff } = this.transcript[index];
+    return {
+      dialogue: structuredClone({
+        conversationHistory: this.transcript.slice(0, index),
+        researchLog: (this.host.plan()?.researchLog ?? []).filter((e) => e.timestamp < cutoff)
+      }),
+      rewoundMessage
+    };
+  }
   /** A one-shot `modifyPlan` exchange. Call inside the host's mutation ritual. */
   recordModification(request, requestedAt, taskCount) {
     this.append("user", request, { timestamp: requestedAt });
@@ -13197,17 +13583,17 @@ function retargetTaskRunner(task, runner, catalog) {
 
 // src/services/SkillsService.ts
 import * as fs8 from "fs";
-import * as path15 from "path";
+import * as path16 from "path";
 
 // src/services/builtinSkills.ts
-import * as path14 from "path";
+import * as path15 from "path";
 import { fileURLToPath } from "url";
 function builtinSkillsDir() {
-  const dir = typeof __dirname !== "undefined" && __dirname ? __dirname : path14.dirname(fileURLToPath(
+  const dir = typeof __dirname !== "undefined" && __dirname ? __dirname : path15.dirname(fileURLToPath(
     // @ts-expect-error - import.meta is only valid under an ESM module setting
     import.meta.url
   ));
-  return path14.join(dir, "..", "skills");
+  return path15.join(dir, "..", "skills");
 }
 
 // src/services/SkillsService.ts
@@ -13246,8 +13632,8 @@ function copyDirSync2(src, dest) {
   fs8.mkdirSync(dest, { recursive: true });
   const entries = fs8.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path15.join(src, entry.name);
-    const destPath = path15.join(dest, entry.name);
+    const srcPath = path16.join(src, entry.name);
+    const destPath = path16.join(dest, entry.name);
     if (entry.isDirectory()) copyDirSync2(srcPath, destPath);
     else fs8.copyFileSync(srcPath, destPath);
   }
@@ -13258,7 +13644,7 @@ function readDir(dir, source) {
   const skills = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const skillFile = path15.join(dir, entry.name, "SKILL.md");
+    const skillFile = path16.join(dir, entry.name, "SKILL.md");
     if (!fs8.existsSync(skillFile)) continue;
     const parsed = parseSkillFile(skillFile, entry.name, source);
     if (parsed) skills.push(parsed);
@@ -13271,17 +13657,17 @@ var SkillsService = class {
   }
   workspaceRoot;
   localDir() {
-    return this.workspaceRoot ? path15.join(this.workspaceRoot, ".ordewell", "skills") : void 0;
+    return this.workspaceRoot ? path16.join(this.workspaceRoot, ".ordewell", "skills") : void 0;
   }
   globalDir() {
-    return path15.join(globalDataDir(), "skills");
+    return path16.join(globalDataDir(), "skills");
   }
   seed(name) {
-    const dest = path15.join(this.globalDir(), name);
+    const dest = path16.join(this.globalDir(), name);
     if (fs8.existsSync(dest)) return false;
     let srcDir;
     try {
-      srcDir = path15.join(builtinSkillsDir(), name);
+      srcDir = path16.join(builtinSkillsDir(), name);
     } catch (err) {
       console.warn(`Could not locate built-in skills dir: ${String(err)}`);
       return false;
@@ -13307,7 +13693,7 @@ var SkillsService = class {
     if (entries.length !== 1 || entries[0].name !== "SKILL.md" || !entries[0].isFile()) return false;
     let raw;
     try {
-      raw = fs8.readFileSync(path15.join(dir, "SKILL.md"), "utf8");
+      raw = fs8.readFileSync(path16.join(dir, "SKILL.md"), "utf8");
     } catch {
       return false;
     }
@@ -13324,7 +13710,7 @@ var SkillsService = class {
   }
   pruneRetired() {
     for (const name of RETIRED_BUILTIN_SKILL_NAMES) {
-      const dest = path15.join(this.globalDir(), name);
+      const dest = path16.join(this.globalDir(), name);
       if (!fs8.existsSync(dest)) continue;
       if (!this.isUnmodifiedRetiredSeed(dest, name)) continue;
       try {
@@ -13339,10 +13725,10 @@ var SkillsService = class {
     if (BUILTIN_SKILL_NAMES.includes(name)) this.seed(name);
     const localDir = this.localDir();
     if (localDir) {
-      const localFile = path15.join(localDir, name, "SKILL.md");
+      const localFile = path16.join(localDir, name, "SKILL.md");
       if (fs8.existsSync(localFile)) return parseSkillFile(localFile, name, "local");
     }
-    const globalFile = path15.join(this.globalDir(), name, "SKILL.md");
+    const globalFile = path16.join(this.globalDir(), name, "SKILL.md");
     if (fs8.existsSync(globalFile)) return parseSkillFile(globalFile, name, "global");
     return void 0;
   }
@@ -13371,7 +13757,7 @@ function createSkillsService(workspaceRoot) {
 
 // src/utils/sessionStore.ts
 import * as fs9 from "fs";
-import * as path16 from "path";
+import * as path17 from "path";
 
 // src/utils/sessionId.ts
 import { randomBytes as randomBytes2 } from "crypto";
@@ -13382,7 +13768,7 @@ function mintSessionId() {
 // src/utils/sessionStore.ts
 var SESSIONS_SUBDIR = "sessions";
 function getSessionsDir(baseDir) {
-  return path16.join(getStateDir(baseDir), SESSIONS_SUBDIR);
+  return path17.join(getStateDir(baseDir), SESSIONS_SUBDIR);
 }
 var REJECTION_MESSAGE = "This session was created with an older version of Ordewell. Please re-plan.";
 function hasScalarRunner(parsed) {
@@ -13404,8 +13790,8 @@ function legacySessionFilename(session) {
   return `${filenameStem(session)}_${session.id.slice(0, 8)}.json`;
 }
 function dropLegacyFile(sessionsDir, meta) {
-  const legacy = path16.join(sessionsDir, legacySessionFilename(meta));
-  if (legacy === path16.join(sessionsDir, sessionFilename(meta)) || !fs9.existsSync(legacy)) return;
+  const legacy = path17.join(sessionsDir, legacySessionFilename(meta));
+  if (legacy === path17.join(sessionsDir, sessionFilename(meta)) || !fs9.existsSync(legacy)) return;
   try {
     const held = JSON.parse(fs9.readFileSync(legacy, "utf-8")).meta?.id;
     if (held === meta.id) fs9.unlinkSync(legacy);
@@ -13431,7 +13817,7 @@ function saveSession(plan, goal, baseDir, id) {
     plan: JSON.parse(JSON.stringify(plan))
   };
   const filename = sessionFilename(meta);
-  const filePath = path16.join(sessionsDir, filename);
+  const filePath = path17.join(sessionsDir, filename);
   fs9.writeFileSync(filePath, JSON.stringify(session, null, 2));
   dropLegacyFile(sessionsDir, meta);
   return meta;
@@ -13442,7 +13828,7 @@ function listSessions(baseDir, logger = defaultLogger) {
   const files = fs9.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
   return files.map((f) => {
     try {
-      const raw = fs9.readFileSync(path16.join(sessionsDir, f), "utf-8");
+      const raw = fs9.readFileSync(path17.join(sessionsDir, f), "utf-8");
       const parsed = JSON.parse(raw);
       if (hasScalarRunner(parsed)) {
         logger.warn("sessionStore", `session file ${f}: ${REJECTION_MESSAGE}`);
@@ -13460,7 +13846,7 @@ function findSessionFile(sessionsDir, sessionId, logger) {
   const files = fs9.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
   for (const f of files) {
     try {
-      const raw = fs9.readFileSync(path16.join(sessionsDir, f), "utf-8");
+      const raw = fs9.readFileSync(path17.join(sessionsDir, f), "utf-8");
       const session = JSON.parse(raw);
       if (session.meta.id === sessionId) return f;
     } catch (err) {
@@ -13475,7 +13861,7 @@ function loadSession(sessionId, baseDir, logger = defaultLogger) {
   try {
     const file = findSessionFile(sessionsDir, sessionId, logger);
     if (file) {
-      const raw = fs9.readFileSync(path16.join(sessionsDir, file), "utf-8");
+      const raw = fs9.readFileSync(path17.join(sessionsDir, file), "utf-8");
       const parsed = JSON.parse(raw);
       if (hasScalarRunner(parsed)) {
         logger.warn("sessionStore", `session file ${file}: ${REJECTION_MESSAGE}`);
@@ -13510,7 +13896,7 @@ function deleteSession(sessionId, baseDir, logger = defaultLogger) {
   try {
     const file = findSessionFile(sessionsDir, sessionId, logger);
     if (file) {
-      fs9.unlinkSync(path16.join(sessionsDir, file));
+      fs9.unlinkSync(path17.join(sessionsDir, file));
       return true;
     }
   } catch (err) {
@@ -14042,26 +14428,30 @@ var Session = class {
    */
   forkConversation() {
     if (!this.plan) throw new ConversationEditError("No planning conversation to fork");
-    const dialogue = this.conversation.clone();
-    const sessionId = mintSessionId();
-    const plan = forkPlanState(this.plan, this.store.planTasks, dialogue, (/* @__PURE__ */ new Date()).toISOString());
-    saveSession(plan, this.goal, this.workspace, sessionId);
-    return { sessionId, goal: this.goal, workspace: this.workspace };
+    return this.saveFork(this.conversation.clone());
   }
   /**
-   * Cut the conversation back to just before a user message (a transcript
-   * position from {@link rewindTargets}). Conversation only: the task list,
-   * and any run executing it, carry on as they are. The planner's live context
-   * is dropped, so the next message replays from the shortened transcript.
+   * Fork the conversation from just before a user message (a transcript
+   * position from {@link rewindTargets}): the fork holds everything said
+   * before it and the current task list, like {@link forkConversation}, and
+   * this session keeps its whole history. The message's full text comes back
+   * so a surface can offer it for resending.
    */
   rewindConversation(userMessageIndex) {
     if (!this.plan) throw new ConversationEditError("No planning conversation to rewind");
-    return this.conversation.rewind(userMessageIndex);
+    const { dialogue, rewoundMessage } = this.conversation.cloneBefore(userMessageIndex);
+    return { ...this.saveFork(dialogue), rewoundMessage };
+  }
+  saveFork(dialogue) {
+    const sessionId = mintSessionId();
+    const plan = forkPlanState(this.plan, this.store.planTasks, dialogue, (/* @__PURE__ */ new Date()).toISOString());
+    saveSession(plan, this.goal, this.workspace, sessionId);
+    return { sessionId, goal: this.goal, workspace: this.workspace };
   }
   /**
    * Condense the conversation on the user's say-so: a hidden planner turn
    * summarises it, and the summary replaces everything but the last two
-   * exchanges. Conversation only, like a rewind — the tasks, and any run
+   * exchanges. Conversation only — the tasks, and any run
    * executing them, are untouched. Atomic: a failed or stopped turn changes
    * nothing.
    */
@@ -14334,8 +14724,9 @@ var Session = class {
    * The opt-in way through a merge conflict: add an AI task, on the conflicted
    * task's own runner and model, that merges its branch by hand in a worktree
    * of its own. When that task lands, the conflicted one lands through it (see
-   * {@link TaskOrchestrator.linkConflictResolver}). Never automatic — nothing
-   * but this call adds it.
+   * {@link TaskOrchestrator.linkConflictResolver}). The automatic answer to a
+   * conflict is a repair, a new attempt of the same task (ADR-0015); a task is
+   * only ever added to the plan by this call.
    */
   async resolveConflictAsTask(taskId) {
     if (!this.plan) return null;
@@ -15088,8 +15479,8 @@ var HeadlessRunner = class extends AbstractRunner {
 import { execFile as execFile3 } from "child_process";
 import { promisify as promisify5 } from "util";
 import { tmpdir } from "os";
-import { join as join15 } from "path";
-import { existsSync as existsSync10, readFileSync as readFileSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "fs";
+import { join as join16 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync7, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "fs";
 
 // src/utils/tmux.ts
 import { execSync as execSync2 } from "child_process";
@@ -15196,7 +15587,7 @@ var TmuxSession = class extends AbstractTerminalSession {
     if (this.exited) return;
     let content;
     try {
-      content = existsSync10(this.logPath) ? readFileSync6(this.logPath, "utf8") : "";
+      content = existsSync11(this.logPath) ? readFileSync7(this.logPath, "utf8") : "";
     } catch {
       return;
     }
@@ -15375,7 +15766,7 @@ var TmuxRunner = class extends AbstractRunner {
       windowName,
       this.execFileImpl,
       this.pollIntervalMs,
-      join15(this.logDir, `${id}.log`),
+      join16(this.logDir, `${id}.log`),
       this.socket
     );
     invocation.env = { ...invocation.env, PATH: await this.resolvePath() };
@@ -15388,8 +15779,8 @@ var TmuxRunner = class extends AbstractRunner {
 
 // src/utils/daemonToken.ts
 import { randomBytes as randomBytes3, timingSafeEqual } from "crypto";
-import { closeSync, mkdirSync as mkdirSync8, openSync, readFileSync as readFileSync7, unlinkSync as unlinkSync3, writeSync } from "fs";
-import { join as join16 } from "path";
+import { closeSync, mkdirSync as mkdirSync9, openSync, readFileSync as readFileSync8, unlinkSync as unlinkSync3, writeSync } from "fs";
+import { join as join17 } from "path";
 var BEARER_PREFIX = "bearer ";
 var DAEMON_TOKEN_SUBPROTOCOL_PREFIX = "ordewell.token.";
 var DAEMON_SUBPROTOCOL = "ordewell.v1";
@@ -15397,12 +15788,12 @@ function configDir() {
   return globalDataDir();
 }
 function daemonTokenPath(port) {
-  return join16(configDir(), `server-${port}.token`);
+  return join17(configDir(), `server-${port}.token`);
 }
 function mintDaemonToken(port) {
   const token = randomBytes3(32).toString("base64url");
   const file = daemonTokenPath(port);
-  mkdirSync8(configDir(), { recursive: true });
+  mkdirSync9(configDir(), { recursive: true });
   try {
     unlinkSync3(file);
   } catch {
@@ -15417,7 +15808,7 @@ function mintDaemonToken(port) {
 }
 function readDaemonToken(port) {
   try {
-    const token = readFileSync7(daemonTokenPath(port), "utf8").trim();
+    const token = readFileSync8(daemonTokenPath(port), "utf8").trim();
     return token === "" ? void 0 : token;
   } catch {
     return void 0;
@@ -15459,17 +15850,17 @@ function tokensMatch(presented, expected) {
 
 // src/plugins/RunnerRegistry.ts
 import * as fs11 from "fs";
-import * as path19 from "path";
+import * as path20 from "path";
 import * as os5 from "os";
 import { execFileSync } from "child_process";
 import { randomBytes as randomBytes4 } from "crypto";
 
 // src/plugins/FsPluginStore.ts
 import * as fs10 from "fs";
-import * as path18 from "path";
+import * as path19 from "path";
 
 // src/plugins/pluginNames.ts
-import * as path17 from "path";
+import * as path18 from "path";
 var PLUGIN_NAME_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/;
 var MAX_PLUGIN_NAME_LENGTH = 64;
 function isPlainPluginName(name) {
@@ -15484,10 +15875,10 @@ function assertPlainPluginName(name) {
 }
 function resolvePluginInstallDir(pluginsDir, name) {
   assertPlainPluginName(name);
-  const root = path17.resolve(pluginsDir);
-  const dest = path17.resolve(root, name);
-  const relative4 = path17.relative(root, dest);
-  if (relative4 !== name || relative4 === "" || path17.isAbsolute(relative4)) {
+  const root = path18.resolve(pluginsDir);
+  const dest = path18.resolve(root, name);
+  const relative5 = path18.relative(root, dest);
+  if (relative5 !== name || relative5 === "" || path18.isAbsolute(relative5)) {
     throw new Error(`Plugin install path escapes the plugins directory: ${JSON.stringify(name)}`);
   }
   return dest;
@@ -15502,10 +15893,10 @@ function isValidManifest(obj) {
 
 // src/plugins/FsPluginStore.ts
 function userPluginsDir() {
-  return path18.join(globalDataDir(), "plugins");
+  return path19.join(globalDataDir(), "plugins");
 }
 function loadManifestFromDir(dir) {
-  const manifestPath = path18.join(dir, "manifest.json");
+  const manifestPath = path19.join(dir, "manifest.json");
   if (!fs10.existsSync(manifestPath)) return null;
   try {
     const raw = fs10.readFileSync(manifestPath, "utf8");
@@ -15520,8 +15911,8 @@ function copyDirSync3(src, dest) {
   ensureDir(dest);
   const entries = fs10.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path18.join(src, entry.name);
-    const destPath = path18.join(dest, entry.name);
+    const srcPath = path19.join(src, entry.name);
+    const destPath = path19.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirSync3(srcPath, destPath);
     } else {
@@ -15533,7 +15924,7 @@ function rmDirSync(dir) {
   if (!fs10.existsSync(dir)) return;
   const entries = fs10.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const p = path18.join(dir, entry.name);
+    const p = path19.join(dir, entry.name);
     if (entry.isDirectory()) {
       rmDirSync(p);
     } else {
@@ -15586,11 +15977,11 @@ var FsPluginStore = class {
       return null;
     }
   }
-  dirExists(path22) {
-    return fs10.existsSync(path22) && fs10.statSync(path22).isDirectory();
+  dirExists(path23) {
+    return fs10.existsSync(path23) && fs10.statSync(path23).isDirectory();
   }
-  exists(path22) {
-    return fs10.existsSync(path22);
+  exists(path23) {
+    return fs10.existsSync(path23);
   }
 };
 
@@ -16022,7 +16413,7 @@ var RunnerRegistry = class {
     return entry?.source === "builtin";
   }
   installFromPath(sourcePath) {
-    const absPath = path19.resolve(sourcePath);
+    const absPath = path20.resolve(sourcePath);
     if (!this.store.dirExists(absPath)) {
       throw new Error(`Plugin source must be a directory: ${absPath}`);
     }
@@ -16034,7 +16425,7 @@ var RunnerRegistry = class {
   }
   installFromGit(url) {
     const validated = assertInstallablePluginUrl(url);
-    const tmpDir = path19.join(os5.tmpdir(), `ordewell-plugin-${randomBytes4(12).toString("hex")}`);
+    const tmpDir = path20.join(os5.tmpdir(), `ordewell-plugin-${randomBytes4(12).toString("hex")}`);
     this.store.ensureDir(tmpDir);
     try {
       try {
@@ -16047,7 +16438,7 @@ var RunnerRegistry = class {
       const hasManifest = contents.some((f) => f === "manifest.json");
       let sourceDir = tmpDir;
       if (!hasManifest) {
-        const onlyEntry = contents.length === 1 ? path19.join(tmpDir, contents[0]) : void 0;
+        const onlyEntry = contents.length === 1 ? path20.join(tmpDir, contents[0]) : void 0;
         if (!onlyEntry || !this.store.dirExists(onlyEntry)) {
           throw new Error(`No manifest.json found in repository: ${validated.toString()}`);
         }
@@ -16095,7 +16486,7 @@ var RunnerRegistry = class {
   }
   createSkeleton(name, outputDir) {
     assertPlainPluginName(name);
-    const dir = path19.resolve(outputDir, name);
+    const dir = path20.resolve(outputDir, name);
     this.store.ensureDir(dir);
     const manifest = {
       name,
@@ -16127,8 +16518,8 @@ var RunnerRegistry = class {
         ]
       }
     };
-    this.store.writeFile(path19.join(dir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
-    const runSh = path19.join(dir, "run.sh");
+    this.store.writeFile(path20.join(dir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+    const runSh = path20.join(dir, "run.sh");
     const scriptContent = `#!/usr/bin/env bash
 # Custom runner script for ${name}
 # Receives:
@@ -16161,14 +16552,14 @@ function fsChmodSync(fpath, mode) {
 
 // src/utils/stateStore.ts
 import * as fs12 from "fs";
-import * as path20 from "path";
+import * as path21 from "path";
 var STATE_FILE = "state.json";
 function getStatePath(baseDir) {
-  return path20.join(getStateDir(baseDir), STATE_FILE);
+  return path21.join(getStateDir(baseDir), STATE_FILE);
 }
 function saveState(plan, baseDir) {
   const statePath = getStatePath(baseDir ?? process.cwd());
-  ensureDir(path20.dirname(statePath));
+  ensureDir(path21.dirname(statePath));
   plan.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
   fs12.writeFileSync(statePath, JSON.stringify(plan, null, 2));
 }
@@ -16203,7 +16594,7 @@ function stateExists(baseDir) {
 
 // src/services/SettingsService.ts
 import * as fs13 from "fs";
-import * as path21 from "path";
+import * as path22 from "path";
 var DEFAULTS = {
   tdd: { enabled: true },
   verification: { enabled: false }
@@ -16211,7 +16602,7 @@ var DEFAULTS = {
 function getSettingsPath() {
   const override = process.env.ORDEWELL_SETTINGS_PATH;
   if (override && override.trim()) return override.trim();
-  return path21.join(globalDataDir(), "settings.json");
+  return path22.join(globalDataDir(), "settings.json");
 }
 function readPlannerModels(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
@@ -16339,7 +16730,7 @@ var SettingsService = class {
     return { ...DEFAULTS, tdd: { ...DEFAULTS.tdd }, verification: { ...DEFAULTS.verification } };
   }
   persist() {
-    const dir = path21.dirname(this.filePath);
+    const dir = path22.dirname(this.filePath);
     if (!fs13.existsSync(dir)) {
       fs13.mkdirSync(dir, { recursive: true });
     }
@@ -16482,6 +16873,7 @@ export {
   augmentPromptWithPriorOutputs,
   augmentedPath,
   bearerHeaderValue,
+  buildConflictRepairPrompt,
   buildConflictResolutionPrompt,
   buildConversationSystemPrompt,
   buildFallbackGrepArgs,
@@ -16501,6 +16893,7 @@ export {
   canMergeTasks,
   canSetDependencies,
   canSplitTask,
+  capConflictFiles,
   checkDepsResolve,
   checkImmutableLog,
   checkInProgress,