@ordewell/core 0.5.0 → 0.5.2

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;
@@ -2636,33 +2637,33 @@ function grepOptions(args) {
   };
 }
 var STOPPED_TOOL_RESULT = "Stopped by the user \u2014 this call was not executed, and no further tool calls will run this turn.";
-async function executeTool(name, args, fs14, fetcher, signal) {
-  const outcome = await runTool(name, args, fs14, fetcher, signal);
+async function executeTool(name, args, fs15, fetcher, signal) {
+  const outcome = await runTool(name, args, fs15, fetcher, signal);
   return { ...outcome, output: redactSecrets(outcome.output) };
 }
-async function runTool(name, args, fs14, fetcher, signal) {
+async function runTool(name, args, fs15, fetcher, signal) {
   if (signal?.aborted) return { success: false, output: STOPPED_TOOL_RESULT, truncated: false };
   switch (name) {
     case "read_file": {
       const offset = num(args.offset);
       const limit = num(args.limit);
       const maxBytes = num(args.maxBytes);
-      return fs14.readFile(String(args.path ?? ""), { offset, limit, maxBytes });
+      return fs15.readFile(String(args.path ?? ""), { offset, limit, maxBytes });
     }
     case "read_files": {
       const paths = Array.isArray(args.paths) ? args.paths.map(String) : [];
-      return fs14.readFiles(paths);
+      return fs15.readFiles(paths);
     }
     case "glob":
-      return fs14.glob(String(args.pattern ?? ""), { path: str(args.path), headLimit: num(args.head_limit ?? args.headLimit) });
+      return fs15.glob(String(args.pattern ?? ""), { path: str(args.path), headLimit: num(args.head_limit ?? args.headLimit) });
     case "grep":
-      return fs14.grep(String(args.pattern ?? ""), grepOptions(args));
+      return fs15.grep(String(args.pattern ?? ""), grepOptions(args));
     case "find_symbol":
-      return fs14.findSymbol(String(args.symbol ?? ""), { language: str(args.language), path: str(args.path) });
+      return fs15.findSymbol(String(args.symbol ?? ""), { language: str(args.language), path: str(args.path) });
     case "list_dir":
-      return fs14.listDir(String(args.path ?? ""), num(args.depth));
+      return fs15.listDir(String(args.path ?? ""), num(args.depth));
     case "bash":
-      return fs14.bash(String(args.command ?? ""), signal);
+      return fs15.bash(String(args.command ?? ""), signal);
     case "fetch": {
       if (!fetcher) return { success: false, output: "Web fetching is not available in this environment.", truncated: false };
       const url = String(args.url ?? "");
@@ -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((resolve7) => {
       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);
+        resolve7(granted);
       };
       const timer = setTimeout(() => settle(false), this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
       timer.unref?.();
@@ -2875,9 +2876,9 @@ function applyHeadLimit(stdout, headLimit) {
 }
 function formatSearchOutput(capped, root, opts) {
   if (capped.rows.length === 0) return opts.emptyMessage;
-  const sep = opts.sep ?? path3.sep;
-  const prefix = root === sep || root.endsWith(sep) ? root : `${root}${sep}`;
-  const body = prefix === sep ? capped.rows.join("\n") : capped.rows.map((row) => row.startsWith(prefix) ? row.slice(prefix.length) : row).join("\n");
+  const sep2 = opts.sep ?? path3.sep;
+  const prefix = root === sep2 || root.endsWith(sep2) ? root : `${root}${sep2}`;
+  const body = prefix === sep2 ? capped.rows.join("\n") : capped.rows.map((row) => row.startsWith(prefix) ? row.slice(prefix.length) : row).join("\n");
   if (!capped.truncated) return body;
   const hint = opts.hint ? ` ${opts.hint}` : "";
   return `${body}
@@ -3468,6 +3469,15 @@ function configuredProviders(config) {
   return out;
 }
 
+// src/utils/maxParallel.ts
+var DEFAULT_MAX_PARALLEL = 3;
+function parseMaxParallel(value) {
+  const text = String(value ?? "").trim();
+  const n = typeof value === "number" ? value : Number(text);
+  if (text === "" || !Number.isInteger(n) || n < 1) return null;
+  return n;
+}
+
 // src/interfaces/BaseConfig.ts
 function normalizeGeminiModel(id) {
   return id.replace(/^gemini:/, "").replace(/^google\//, "");
@@ -3475,6 +3485,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() {
@@ -3668,7 +3682,7 @@ var BaseConfig = class {
     return "";
   }
   get maxParallelSessions() {
-    return parseInt(process.env.ORDEWELL_MAX_PARALLEL || "3", 10);
+    return parseMaxParallel(process.env.ORDEWELL_MAX_PARALLEL) ?? DEFAULT_MAX_PARALLEL;
   }
   get researchEnabled() {
     return process.env.ORDEWELL_RESEARCH_ENABLED !== "false";
@@ -3697,6 +3711,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 +3773,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 +3804,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 +3833,28 @@ function posixBinDirs() {
   ];
 }
 function windowsBinDirs(env, home) {
-  const join21 = (...parts) => path4.win32.join(...parts);
-  const under = (base, ...parts) => base ? [join21(base, ...parts)] : [];
+  const join23 = (...parts) => path4.win32.join(...parts);
+  const under = (base, ...parts) => base ? [join23(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"),
+    join23(home, ".local", "bin"),
+    join23(home, ".opencode", "bin"),
+    join23(home, ".claude", "bin"),
+    join23(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"),
+    join23(home, "AppData", "Roaming", "npm"),
     ...under(localAppData, "pnpm"),
     ...under(localAppData, "Yarn", "bin"),
-    join21(home, ".bun", "bin"),
+    join23(home, ".bun", "bin"),
     // Windows package managers.
-    join21(home, "scoop", "shims"),
+    join23(home, "scoop", "shims"),
     ...under(env.SCOOP, "shims"),
     ...under(env.SCOOP_GLOBAL ?? programData, "scoop", "shims"),
     ...under(programData, "chocolatey", "bin"),
@@ -3843,7 +3864,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")
+    join23(home, ".volta", "bin")
   ];
 }
 function wellKnownBinDirs(deps = {}) {
@@ -3947,6 +3968,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 +3987,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 +4050,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 +4076,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 +4123,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 +4140,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 +4213,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 +4229,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 +4246,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 +4269,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 +4325,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 +4340,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 +4362,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 +4380,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 +4391,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 +4445,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 +4465,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 +4485,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 +4580,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 +4685,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 +4711,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 +4785,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 +4828,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 +4855,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 +4881,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 +4901,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 +5368,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 +5460,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 +5562,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 +5840,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 resolve7 = "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 ${resolve7} 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 ${resolve7} 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) {
@@ -5958,8 +6195,8 @@ function compactResearchResults(resultsText, maxChars = COMPACTION_LIMITS.resear
 
 // src/services/ContextCollector.ts
 var ORDEWELL_CONTEXT_MAX = 8e3;
-async function collectResearchContext(fs14, runners) {
-  const collector = new ContextCollector(fs14);
+async function collectResearchContext(fs15, runners) {
+  const collector = new ContextCollector(fs15);
   let contextStr = "";
   let firstContext = null;
   for (const r of runners) {
@@ -5986,8 +6223,8 @@ ${firstContext.dirStructure}
   return contextStr;
 }
 var ContextCollector = class {
-  constructor(fs14, registry) {
-    this.fs = fs14;
+  constructor(fs15, registry) {
+    this.fs = fs15;
     this.registry = registry;
   }
   fs;
@@ -6035,22 +6272,22 @@ var ALLOWED_TOOL_NAMES = new Set(subagentToolSpecs().map((t) => t.name));
 function refused(output) {
   return { success: false, output, truncated: false };
 }
-function nonPromptingFs(fs14) {
-  const withinWorkspace = (p) => resolveWithin(fs14.getWorkspaceRoot(), p ?? ".").inside;
+function nonPromptingFs(fs15) {
+  const withinWorkspace = (p) => resolveWithin(fs15.getWorkspaceRoot(), p ?? ".").inside;
   const outsideRefusal = (p) => refused(
     `Path "${p}" is outside the workspace. Research agents are confined to the workspace root \u2014 note the gap in your digest and let the planner request it directly.`
   );
   return {
-    getWorkspaceRoot: () => fs14.getWorkspaceRoot(),
-    readFile: (p, opts) => withinWorkspace(p) ? fs14.readFile(p, opts) : Promise.resolve(outsideRefusal(p)),
+    getWorkspaceRoot: () => fs15.getWorkspaceRoot(),
+    readFile: (p, opts) => withinWorkspace(p) ? fs15.readFile(p, opts) : Promise.resolve(outsideRefusal(p)),
     readFiles: (paths) => {
       const escaping = paths.find((p) => !withinWorkspace(p));
-      return escaping ? Promise.resolve(outsideRefusal(escaping)) : fs14.readFiles(paths);
+      return escaping ? Promise.resolve(outsideRefusal(escaping)) : fs15.readFiles(paths);
     },
-    glob: (pattern, opts) => withinWorkspace(opts?.path) ? fs14.glob(pattern, opts) : Promise.resolve(outsideRefusal(opts.path)),
-    grep: (pattern, opts) => withinWorkspace(opts?.path) ? fs14.grep(pattern, opts) : Promise.resolve(outsideRefusal(opts.path)),
-    findSymbol: (symbol, opts) => withinWorkspace(opts?.path) ? fs14.findSymbol(symbol, opts) : Promise.resolve(outsideRefusal(opts.path)),
-    listDir: (p, depth) => withinWorkspace(p) ? fs14.listDir(p, depth) : Promise.resolve(outsideRefusal(p)),
+    glob: (pattern, opts) => withinWorkspace(opts?.path) ? fs15.glob(pattern, opts) : Promise.resolve(outsideRefusal(opts.path)),
+    grep: (pattern, opts) => withinWorkspace(opts?.path) ? fs15.grep(pattern, opts) : Promise.resolve(outsideRefusal(opts.path)),
+    findSymbol: (symbol, opts) => withinWorkspace(opts?.path) ? fs15.findSymbol(symbol, opts) : Promise.resolve(outsideRefusal(opts.path)),
+    listDir: (p, depth) => withinWorkspace(p) ? fs15.listDir(p, depth) : Promise.resolve(outsideRefusal(p)),
     bash: async (command, signal) => {
       const dialect = resolveResearchShell().dialect;
       const { tier, reason } = classifyCommand(command, { dialect });
@@ -6061,13 +6298,13 @@ function nonPromptingFs(fs14) {
       }
       const escaping = pathLikeArgs(command, { dialect }).find((p) => !withinWorkspace(p));
       if (escaping) return outsideRefusal(escaping);
-      return fs14.bash(command, signal);
+      return fs15.bash(command, signal);
     }
   };
 }
 async function runLoop(prompt, deps) {
   if (deps.signal?.aborted) return "[research agent aborted before starting]";
-  const fs14 = nonPromptingFs(deps.fs);
+  const fs15 = nonPromptingFs(deps.fs);
   const chat = deps.createChat((delta) => deps.onProgress?.({ type: "thinking", text: delta }));
   let turn = await chat.sendMessage(prompt, deps.signal);
   for (let step = 0; turn.hasToolCalls && step < SUBAGENT_LIMITS.maxSteps; step++) {
@@ -6084,7 +6321,7 @@ ${turn.text}`;
       if (tc.name === "read_file" && !("maxBytes" in args) && !("limit" in args)) args.limit = 2e3;
       const toolArgs = JSON.stringify(tc.args);
       deps.onProgress?.({ type: "tool_call", tool: tc.name, toolArgs, toolCallId: tc.id });
-      const res = await executeTool(tc.name, args, fs14, void 0, deps.signal);
+      const res = await executeTool(tc.name, args, fs15, void 0, deps.signal);
       const output = res.output.length > SUBAGENT_LIMITS.toolOutputMaxChars ? res.output.slice(0, SUBAGENT_LIMITS.toolOutputMaxChars) + `
 [... truncated to ${SUBAGENT_LIMITS.toolOutputMaxChars} chars, total ${res.output.length}]` : res.output;
       const stepEntry = {
@@ -6200,7 +6437,7 @@ var BaseAiService = class _BaseAiService {
    * steering/failed result and the loop continues sequentially: a subagent can
    * never fail a plan or a turn.
    */
-  async executeSpawnAgent(args, fs14, onProgress, signal, subagentId) {
+  async executeSpawnAgent(args, fs15, onProgress, signal, subagentId) {
     const prompt = typeof args.prompt === "string" ? args.prompt.trim() : "";
     if (!prompt) {
       return { success: false, output: 'spawn_research_agent requires a non-empty "prompt" string: a self-contained task for the agent, including what its digest must report back.', truncated: false };
@@ -6211,20 +6448,20 @@ var BaseAiService = class _BaseAiService {
         if (!chat) throw new Error("subagent chats are not available for this provider");
         return chat;
       },
-      fs: fs14,
+      fs: fs15,
       signal,
       onProgress: (progress) => onProgress({ ...progress, subagentId })
     });
   }
   /** Collect project context for the planning phase. Shared with the harness backend. */
-  static async collectResearchContext(fs14, runners) {
-    return collectResearchContext(fs14, runners);
+  static async collectResearchContext(fs15, runners) {
+    return collectResearchContext(fs15, runners);
   }
   /**
    * Execute one round of tool calls and report each through onProgress.
    * Returns the results to feed back plus the log entries produced.
    */
-  async executeToolCalls(toolCalls, fs14, onProgress, fetcher, stepIndex, thinking, signal) {
+  async executeToolCalls(toolCalls, fs15, onProgress, fetcher, stepIndex, thinking, signal) {
     const toolResults = [];
     const logEntries = [];
     let resultsText = "";
@@ -6243,18 +6480,18 @@ var BaseAiService = class _BaseAiService {
         const subagentId = uuidv4();
         spawnSubagentIds.set(i, subagentId);
         onProgress({ type: "tool_call", tool: toolCalls[i].name, toolArgs: JSON.stringify(toolCalls[i].args), subagentId, toolCallId: toolCalls[i].id });
-        precomputed.set(i, await this.executeSpawnAgent({ ...toolCalls[i].args }, fs14, onProgress, signal, subagentId));
+        precomputed.set(i, await this.executeSpawnAgent({ ...toolCalls[i].args }, fs15, onProgress, signal, subagentId));
       }) : Promise.resolve(),
       parallelIndexes.length > 1 ? mapWithConcurrency(parallelIndexes, TOOL_ROUND_CONCURRENCY, async (i) => {
         onProgress({ type: "tool_call", tool: toolCalls[i].name, toolArgs: JSON.stringify(toolCalls[i].args), toolCallId: toolCalls[i].id });
-        precomputed.set(i, await executeTool(toolCalls[i].name, normalizedArgs[i], fs14, fetcher, signal));
+        precomputed.set(i, await executeTool(toolCalls[i].name, normalizedArgs[i], fs15, fetcher, signal));
       }) : Promise.resolve()
     ]);
     for (const [index, tc] of toolCalls.entries()) {
       const toolArgs = normalizedArgs[index];
       const preResult = precomputed.get(index);
       if (!preResult) onProgress({ type: "tool_call", tool: tc.name, toolArgs: JSON.stringify(tc.args), toolCallId: tc.id });
-      const toolResult = preResult ?? await executeTool(tc.name, toolArgs, fs14, fetcher, signal);
+      const toolResult = preResult ?? await executeTool(tc.name, toolArgs, fs15, fetcher, signal);
       const MAX_RESPONSE_CHARS = 5e4;
       const truncatedResponse = toolResult.success && (toolResult.truncated || toolResult.output.length > MAX_RESPONSE_CHARS);
       const llmOutput = toolResult.output.length > MAX_RESPONSE_CHARS ? toolResult.output.slice(0, MAX_RESPONSE_CHARS) + `
@@ -6440,7 +6677,7 @@ ${llmOutput}
    * parsed tasks if a plan was emitted mid-loop, or null if the loop
    * exhausted without a valid plan.
    */
-  async runResearchLoop(chat, firstMessage, fs14, onProgress, runners, initialLog, fetcher, userGoal, runnerModes, autonomousDefault, signal) {
+  async runResearchLoop(chat, firstMessage, fs15, onProgress, runners, initialLog, fetcher, userGoal, runnerModes, autonomousDefault, signal) {
     const researchLog = initialLog ? [...initialLog] : [];
     if (!initialLog && userGoal) {
       researchLog.push({
@@ -6467,7 +6704,7 @@ ${llmOutput}
       if (!turn.hasToolCalls) break;
       const { toolResults, logEntries, resultsText } = await this.executeToolCalls(
         turn.toolCalls,
-        fs14,
+        fs15,
         onProgress,
         fetcher,
         step,
@@ -6702,11 +6939,11 @@ ${repairHint}` }] : parts;
     return this.consumePlanStream(result, onToken);
   }
   // --- IAiService implementation ---
-  async researchAndPlan(userDescription, runners, modelsByRunner, fs14, onProgress, fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+  async researchAndPlan(userDescription, runners, modelsByRunner, fs15, onProgress, fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     const genModel = this.getPlanningModel();
-    const contextStr = await BaseAiService.collectResearchContext(fs14, runners);
+    const contextStr = await BaseAiService.collectResearchContext(fs15, runners);
     const systemPrompt = buildResearchPrompt(userDescription, contextStr, modelsByRunner, runners, runnerModes, modes);
     const firstMessage = `${buildResearchToolsPrompt()}
 
@@ -6717,17 +6954,17 @@ Explore the workspace to understand the codebase, then generate the plan.`;
       generationConfig: { temperature: 0.3, topP: 0.95, maxOutputTokens: 16384 }
     });
     const researchChat = new GeminiResearchChat(chat);
-    const result = await this.runResearchLoop(researchChat, firstMessage, fs14, onProgress, runners, void 0, fetcher, userDescription, runnerModes, autonomousDefault, signal);
+    const result = await this.runResearchLoop(researchChat, firstMessage, fs15, onProgress, runners, void 0, fetcher, userDescription, runnerModes, autonomousDefault, signal);
     if (result.tasks) return { tasks: result.tasks, researchLog: result.researchLog, researchResults: result.researchResults };
     const fallback = await this.generatePlanFallback(userDescription, contextStr, result.researchResults, modelsByRunner, runners, onProgress, result.researchLog, runnerModes, autonomousDefault, signal, modes);
     return { tasks: fallback.tasks, researchLog: fallback.researchLog, researchResults: result.researchResults };
   }
-  async generatePlanDirect(userDescription, runners = ["claude-code"], modelsByRunner = {}, onToken, fs14, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, _signal) {
+  async generatePlanDirect(userDescription, runners = ["claude-code"], modelsByRunner = {}, onToken, fs15, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, _signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     let ctx = "";
-    if (fs14) {
-      const collected = await new ContextCollector(fs14).collect(runners[0] ?? "claude-code");
+    if (fs15) {
+      const collected = await new ContextCollector(fs15).collect(runners[0] ?? "claude-code");
       if (collected.aiflowContext) ctx = `
 <aiflow_context>
 ${collected.aiflowContext}
@@ -6743,12 +6980,12 @@ ${collected.aiflowContext}
       autonomousDefault
     );
   }
-  async modifyPlan(existingPlan, userRequest, modelsByRunner, onProgress, fs14, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, _signal) {
+  async modifyPlan(existingPlan, userRequest, modelsByRunner, onProgress, fs15, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, _signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     let aiflowContext;
-    if (fs14) {
-      const collected = await new ContextCollector(fs14).collect(existingPlan.runners[0] ?? "claude-code");
+    if (fs15) {
+      const collected = await new ContextCollector(fs15).collect(existingPlan.runners[0] ?? "claude-code");
       if (collected.aiflowContext) aiflowContext = collected.aiflowContext;
     }
     const prompt = buildModifyPlanPrompt(existingPlan, userRequest, modelsByRunner, aiflowContext, runnerModes, autonomousDefault);
@@ -6984,11 +7221,11 @@ ${buildResearchToolsPrompt()}` }
     }
   }
   // --- IAiService implementation ---
-  async researchAndPlan(userDescription, runners, modelsByRunner, fs14, onProgress, fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+  async researchAndPlan(userDescription, runners, modelsByRunner, fs15, onProgress, fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
     this.ensureInit();
     const client = this.getClient();
     const { autonomousDefault } = modes;
-    const contextStr = await BaseAiService.collectResearchContext(fs14, runners);
+    const contextStr = await BaseAiService.collectResearchContext(fs15, runners);
     const systemPrompt = buildResearchPrompt(userDescription, contextStr, modelsByRunner, runners, runnerModes, modes);
     const userText = `User goal: ${userDescription}`;
     const firstMessage = `${buildResearchToolsPrompt()}
@@ -7006,17 +7243,17 @@ ${userText}`;
       toOpenAiTools(),
       (delta) => onProgress({ type: "thinking", text: delta })
     );
-    const result = await this.runResearchLoop(researchChat, firstMessage, fs14, onProgress, runners, void 0, fetcher, userDescription, runnerModes, autonomousDefault, signal);
+    const result = await this.runResearchLoop(researchChat, firstMessage, fs15, onProgress, runners, void 0, fetcher, userDescription, runnerModes, autonomousDefault, signal);
     if (result.tasks) return { tasks: result.tasks, researchLog: result.researchLog, researchResults: result.researchResults };
     const fallback = await this.generatePlanFallback(userDescription, contextStr, result.researchResults, modelsByRunner, runners, onProgress, result.researchLog, runnerModes, autonomousDefault, signal, modes);
     return { tasks: fallback.tasks, researchLog: fallback.researchLog, researchResults: result.researchResults };
   }
-  async generatePlanDirect(userDescription, runners = ["claude-code"], modelsByRunner = {}, onToken, fs14, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+  async generatePlanDirect(userDescription, runners = ["claude-code"], modelsByRunner = {}, onToken, fs15, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     let ctx = "";
-    if (fs14) {
-      const collected = await new ContextCollector(fs14).collect(runners[0] ?? "claude-code");
+    if (fs15) {
+      const collected = await new ContextCollector(fs15).collect(runners[0] ?? "claude-code");
       if (collected.aiflowContext) ctx = `
 <aiflow_context>
 ${collected.aiflowContext}
@@ -7032,12 +7269,12 @@ ${collected.aiflowContext}
       autonomousDefault
     );
   }
-  async modifyPlan(existingPlan, userRequest, modelsByRunner, onProgress, fs14, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+  async modifyPlan(existingPlan, userRequest, modelsByRunner, onProgress, fs15, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     let aiflowContext;
-    if (fs14) {
-      const collected = await new ContextCollector(fs14).collect(existingPlan.runners[0] ?? "claude-code");
+    if (fs15) {
+      const collected = await new ContextCollector(fs15).collect(existingPlan.runners[0] ?? "claude-code");
       if (collected.aiflowContext) aiflowContext = collected.aiflowContext;
     }
     const prompt = buildModifyPlanPrompt(existingPlan, userRequest, modelsByRunner, aiflowContext, runnerModes, autonomousDefault);
@@ -7056,6 +7293,9 @@ ${collected.aiflowContext}
   }
 };
 
+// src/services/TaskOrchestrator.ts
+import * as path11 from "path";
+
 // src/services/promptAugment.ts
 var MAX_TAIL_CHARS = 500;
 var DEFAULT_PLAN_MAP_MAX_ENTRIES = 30;
@@ -7641,18 +7881,230 @@ ${line}
 };
 
 // src/services/transcriptCapture.ts
-import { readFileSync, readdirSync as readdirSync2, statSync as statSync4, existsSync as existsSync3 } from "fs";
+import { readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync5, existsSync as existsSync4 } from "fs";
+import * as os4 from "os";
+import * as path10 from "path";
+
+// src/services/workspaceEnv.ts
+import { execFile as execFile2 } from "child_process";
+import * as fs5 from "fs";
 import * as os3 from "os";
-import * as path8 from "path";
+import * as path9 from "path";
+
+// src/services/settingsEnvAllowlist.ts
+var ORDEWELL_SETTABLE_ENV = [
+  "AI_PROVIDER",
+  "ORCHESTRATOR_MODEL",
+  "ORDEWELL_SUBAGENT_MODEL",
+  "ORDEWELL_PLANNER_EFFORT",
+  "ORDEWELL_RESEARCH_ENABLED",
+  "ORDEWELL_MAX_PARALLEL",
+  "ORDEWELL_CONFLICT_REPAIR_ATTEMPTS"
+];
+var SETTINGS_ENV_REFUSED = [
+  // Approval posture and pre-approved scope.
+  "ORDEWELL_AUTONOMOUS_MODE",
+  "ORDEWELL_APPROVAL_MODE",
+  "ORDEWELL_APPROVAL_ALLOW",
+  // Where settings are persisted.
+  "ORDEWELL_SETTINGS_PATH",
+  // Runtime options and dynamic loaders.
+  "NODE_OPTIONS",
+  "NODE_REPL_EXTERNAL_MODULE",
+  "NODE_PATH",
+  "ELECTRON_RUN_AS_NODE",
+  "LD_PRELOAD",
+  "LD_LIBRARY_PATH",
+  "LD_AUDIT",
+  "DYLD_INSERT_LIBRARIES",
+  "DYLD_LIBRARY_PATH",
+  "DYLD_FRAMEWORK_PATH",
+  // Executable resolution.
+  "PATH",
+  "PATHEXT",
+  "NODE"
+];
+var REFUSED = new Set(SETTINGS_ENV_REFUSED);
+function providerEnvKeys() {
+  const keys = [];
+  for (const meta of Object.values(ALL_PROVIDERS)) {
+    if (meta.apiKeyEnvVar) keys.push(meta.apiKeyEnvVar);
+    if (meta.baseUrlEnvVar) keys.push(meta.baseUrlEnvVar);
+    for (const detect of meta.detectEnvVars) keys.push(detect);
+  }
+  return keys;
+}
+var PROVIDER_CREDENTIAL_ENV = new Set(providerEnvKeys());
+var SETTINGS_ENV_ALLOWLIST = new Set(
+  [...providerEnvKeys(), ...ORDEWELL_SETTABLE_ENV].filter((key) => !REFUSED.has(key))
+);
+function admitSettingsEnv(env) {
+  const accepted = {};
+  const rejected = [];
+  for (const [key, value] of Object.entries(env)) {
+    if (REFUSED.has(key) || !SETTINGS_ENV_ALLOWLIST.has(key) || typeof value !== "string") {
+      rejected.push(key);
+      continue;
+    }
+    accepted[key] = value;
+  }
+  return { accepted, rejected };
+}
+
+// src/services/workspaceEnv.ts
+var WORKSPACE_ENV_FILE = "env";
+var DIRENV_TIMEOUT_MS = 5e3;
+var KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function defaultDeps() {
+  return {
+    run: (command, args, opts) => new Promise((resolve7) => {
+      execFile2(command, args, { ...opts, timeout: DIRENV_TIMEOUT_MS, encoding: "utf8" }, (err, stdout, stderr) => {
+        const code = err ? typeof err.code === "number" ? Number(err.code) : -1 : 0;
+        resolve7({ code, stdout: String(stdout ?? ""), stderr: String(stderr ?? "") });
+      });
+    }),
+    readFile: (file) => {
+      try {
+        return fs5.readFileSync(file, "utf8");
+      } catch {
+        return null;
+      }
+    },
+    isDirectory: (dir) => {
+      try {
+        return fs5.statSync(dir).isDirectory();
+      } catch {
+        return false;
+      }
+    },
+    baseEnv: process.env,
+    home: os3.homedir()
+  };
+}
+var REFUSED2 = new Set(SETTINGS_ENV_REFUSED);
+async function resolveWorkspaceEnv(cwd, overrides = {}) {
+  const deps = { ...defaultDeps(), ...overrides };
+  const result = { env: {}, blockedEnvrc: null, refused: [], trackedEnvFile: null };
+  if (!deps.isDirectory(cwd)) return result;
+  const collected = {};
+  const direnv = await fromDirenv(checkoutDirOf(cwd, deps), deps);
+  result.blockedEnvrc = direnv.blocked;
+  Object.assign(collected, direnv.env);
+  const file = findUp(cwd, path9.join(STATE_DIR, WORKSPACE_ENV_FILE), deps);
+  if (file) {
+    const content = deps.readFile(file);
+    if (content !== null) {
+      if (await isTracked(file, deps)) result.trackedEnvFile = file;
+      else Object.assign(collected, parseEnvFile(content, { ...deps.baseEnv, ...collected }, deps.home));
+    }
+  }
+  for (const [key, value] of Object.entries(collected)) {
+    if (!KEY.test(key)) continue;
+    if (REFUSED2.has(key) || key.toUpperCase() === "PATH") result.refused.push(key);
+    else result.env[key] = value;
+  }
+  return result;
+}
+async function workspaceEnvOf(cwd) {
+  return (await resolveWorkspaceEnv(cwd)).env;
+}
+function checkoutDirOf(cwd, deps) {
+  const parts = path9.resolve(cwd).split(path9.sep);
+  const at = parts.findIndex((part, i) => part === STATE_DIR && parts[i + 1] === "worktrees");
+  if (at < 0 || parts.length < at + 4) return cwd;
+  const root = parts.slice(0, at).join(path9.sep) || path9.sep;
+  const mapped = path9.join(root, ...parts.slice(at + 4));
+  return deps.isDirectory(mapped) ? mapped : root;
+}
+async function fromDirenv(cwd, deps) {
+  const setting = deps.baseEnv.ORDEWELL_DIRENV;
+  if (setting === "false" || setting === "0") return { env: {}, blocked: null };
+  const baseEnv = Object.fromEntries(Object.entries(deps.baseEnv).filter(([key]) => !key.startsWith("DIRENV_")));
+  let out;
+  try {
+    out = await deps.run("direnv", ["export", "json"], { cwd, env: baseEnv });
+  } catch {
+    return { env: {}, blocked: null };
+  }
+  const blocked = out.stderr.match(/error (\S*\.envrc) is blocked/);
+  if (blocked) return { env: {}, blocked: blocked[1] };
+  if (out.code !== 0 || !out.stdout.trim()) return { env: {}, blocked: null };
+  let parsed;
+  try {
+    parsed = JSON.parse(out.stdout);
+  } catch {
+    return { env: {}, blocked: null };
+  }
+  if (!parsed || typeof parsed !== "object") return { env: {}, blocked: null };
+  const env = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (typeof value === "string" && !key.startsWith("DIRENV_")) env[key] = value;
+  }
+  return { env, blocked: null };
+}
+function findUp(start, relative5, deps) {
+  let dir = path9.resolve(start);
+  for (; ; ) {
+    const candidate = path9.join(dir, relative5);
+    if (deps.readFile(candidate) !== null) return candidate;
+    const parent = path9.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+async function isTracked(file, deps) {
+  try {
+    const out = await deps.run("git", ["ls-files", "--error-unmatch", path9.basename(file)], { cwd: path9.dirname(file), env: deps.baseEnv });
+    return out.code === 0;
+  } catch {
+    return false;
+  }
+}
+function parseEnvFile(content, context, home) {
+  const env = {};
+  const lookup2 = (name) => env[name] ?? context[name] ?? "";
+  const expand = (value) => {
+    const tilde = value.startsWith("~/") ? path9.join(home, value.slice(2)) : value;
+    return tilde.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, braced, bare) => lookup2(braced ?? bare));
+  };
+  for (const raw of content.split(/\r?\n/)) {
+    const line = raw.trim().replace(/^export\s+/, "");
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    if (!KEY.test(key)) continue;
+    const rest = line.slice(eq + 1).trim();
+    if (rest.startsWith("'")) {
+      const end = rest.indexOf("'", 1);
+      env[key] = end > 0 ? rest.slice(1, end) : rest.slice(1);
+    } else if (rest.startsWith('"')) {
+      const end = rest.lastIndexOf('"');
+      env[key] = expand((end > 0 ? rest.slice(1, end) : rest.slice(1)).replace(/\\n/g, "\n").replace(/\\"/g, '"'));
+    } else {
+      env[key] = expand(rest.replace(/\s+#.*$/, ""));
+    }
+  }
+  return env;
+}
+
+// src/services/transcriptCapture.ts
 var HomeTranscriptReader = class {
   home;
+  claudeConfigDirs;
   constructor(opts = {}) {
     const { homeDir } = opts;
-    this.home = homeDir ? () => homeDir : () => process.env.HOME || os3.homedir();
+    this.home = homeDir ? () => homeDir : () => process.env.HOME || os4.homedir();
+    const workspaceEnv = opts.workspaceEnv ?? workspaceEnvOf;
+    this.claudeConfigDirs = async (cwd) => [...new Set([
+      (await workspaceEnv(cwd)).CLAUDE_CONFIG_DIR,
+      homeDir ? void 0 : process.env.CLAUDE_CONFIG_DIR,
+      path10.join(this.home(), ".claude")
+    ].filter((dir) => Boolean(dir)))];
   }
   async finalAssistantText(query, maxChars = 4e3) {
     try {
-      if (query.runner === "claude-code") return claudeFinal(this.home(), query, maxChars);
+      if (query.runner === "claude-code") return claudeFinal(await this.claudeConfigDirs(query.cwd), query, maxChars);
       if (query.runner === "opencode") return await opencodeFinal(this.home(), query, maxChars);
       if (query.runner === "codex") return codexFinal(this.home(), query, maxChars);
     } catch {
@@ -7661,22 +8113,22 @@ var HomeTranscriptReader = class {
   }
 };
 var CLAUDE_PROJECT_NAME_MAX = 200;
-function claudeProjectDirs(home, cwd) {
-  const projects = path8.join(home, ".claude", "projects");
+function claudeProjectDirs(configDir2, cwd) {
+  const projects = path10.join(configDir2, "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 = path10.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) => path10.join(projects, name));
 }
-function claudeFinal(home, query, maxChars) {
+function claudeFinal(configDirs, 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 = configDirs.flatMap((dir) => claudeProjectDirs(dir, query.cwd)).flatMap((dir) => readdirSync3(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path10.join(dir, f))).filter((f) => cutoff ? statSync5(f).mtimeMs >= cutoff - 5e3 : true).sort((a, b) => statSync5(b).mtimeMs - statSync5(a).mtimeMs);
   for (const file of candidates) {
-    const raw = readFileSync(file, "utf8");
+    const raw = readFileSync3(file, "utf8");
     if (!raw.includes(query.marker)) continue;
     const text = claudeLastAssistant(raw);
     if (text) return clamp(text, maxChars);
@@ -7710,8 +8162,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 = path10.join(home, ".local", "share", "opencode", "opencode.db");
+  if (!existsSync4(dbPath)) return null;
   let db;
   try {
     db = new DatabaseSync(dbPath, { open: true });
@@ -7763,8 +8215,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 = path10.join(home, ".codex", "sessions");
+  if (!existsSync4(root)) return null;
   const cutoff = query.startedAt ? Date.parse(query.startedAt) : 0;
   const files = [];
   const stack = [root];
@@ -7772,15 +8224,15 @@ 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 = path10.join(dir, e);
       let st;
       try {
-        st = statSync4(full);
+        st = statSync5(full);
       } catch {
         continue;
       }
@@ -7788,7 +8240,7 @@ function codexFinal(home, query, maxChars) {
       else if (e.startsWith("rollout-") && e.endsWith(".jsonl") && (!cutoff || st.mtimeMs >= cutoff - 5e3)) files.push(full);
     }
   }
-  files.sort((a, b) => statSync4(b).mtimeMs - statSync4(a).mtimeMs);
+  files.sort((a, b) => statSync5(b).mtimeMs - statSync5(a).mtimeMs);
   for (const file of cutoff ? files : files.slice(0, 10)) {
     const text = codexLastAssistant(file, query);
     if (text) return clamp(text, maxChars);
@@ -7796,7 +8248,7 @@ function codexFinal(home, query, maxChars) {
   return null;
 }
 function codexLastAssistant(file, query) {
-  const raw = readFileSync(file, "utf8");
+  const raw = readFileSync3(file, "utf8");
   if (!raw.includes(query.marker)) return null;
   const lines = raw.split("\n").filter((l) => l.trim());
   let sawCwd = false;
@@ -8228,6 +8680,43 @@ ${taskB.description}`,
   }
 };
 
+// src/utils/shell.ts
+var ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]|\x1b\][^\x07]*\x07|\x1b[()][AB012]|\r/g;
+function stripAnsi(text) {
+  return text.replace(ANSI_RE, "");
+}
+function posixShellQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function buildShellInvocation(command, args) {
+  const inner = [command, ...args].map(posixShellQuote).join(" ");
+  return { shellPath: "/bin/bash", shellArgs: ["-lc", inner] };
+}
+function wrapWithPty(command, args, opts = {}) {
+  const inner = [command, ...args].map(posixShellQuote).join(" ");
+  const watcher = opts.controlChannel ? 'exec 4<&0; ( while read -r C R <&3; do stty cols "$C" rows "$R" <&4; done ) & ' : "";
+  const setup = opts.size ? `stty cols ${opts.size.cols} rows ${opts.size.rows}; ` : "";
+  return { command: "script", args: ["-q", "-e", "-f", "-c", `${watcher}${setup}${inner}`, "/dev/null"] };
+}
+
+// src/services/blockingPrompts.ts
+var TAIL = 4096;
+var squash = (text) => stripAnsi(text).replace(/\s+/g, "").toLowerCase();
+function watchBlockingPrompts(session, prompts, onPrompt) {
+  if (prompts.length === 0) return;
+  const pending = prompts.map((prompt) => ({ prompt, phrase: squash(prompt.phrase) }));
+  let tail = "";
+  session.onOutput((text) => {
+    if (pending.length === 0) return;
+    tail = (tail + squash(text)).slice(-TAIL);
+    for (let i = pending.length - 1; i >= 0; i--) {
+      if (!tail.includes(pending[i].phrase)) continue;
+      onPrompt(pending[i].prompt);
+      pending.splice(i, 1);
+    }
+  });
+}
+
 // src/services/TaskOrchestrator.ts
 var SHARED_ROOT_TAIL = "tasks run in the workspace root without worktree isolation.";
 function sharedRootNotice(reason, repos) {
@@ -8291,6 +8780,25 @@ var TaskOrchestrator = class {
    */
   retryCounts = /* @__PURE__ */ new Map();
   spawnCounts = /* @__PURE__ */ new Map();
+  /**
+   * The terminal a verdict left open, by task. It stays so the user can read
+   * the agent's output or keep talking to it — but only while its worktree
+   * does: once that is removed the agent sits in a deleted directory, and a
+   * newer attempt in the same worktree would share it with a second agent.
+   * Without this, every task of every run left one agent process running
+   * until the daemon stopped.
+   */
+  lingering = /* @__PURE__ */ new Map();
+  /**
+   * A full-plan run a failure paused. Retrying the failed task is the explicit
+   * resume the pause waits for — without this a retry only reset the task to
+   * pending and nothing ran until the user also re-ran the whole plan.
+   */
+  haltedByFailure = false;
+  /** The workspace's own variables for a task's cwd (ADR-0016); swapped out in tests. */
+  workspaceEnv = (cwd) => resolveWorkspaceEnv(cwd);
+  /** What the workspace env has already warned about, so a run says it once, not per task. */
+  envWarnings = /* @__PURE__ */ new Set();
   /**
    * Tasks pulled out of auto-scheduling (user-cancelled or failed to spawn).
    * They stay 'pending' — "not executed" — but the scheduler skips them until
@@ -8334,6 +8842,32 @@ var TaskOrchestrator = class {
   setWorkspaceRoot(fn) {
     this.workspaceRootFn = fn;
   }
+  setWorkspaceEnvResolver(resolve7) {
+    this.workspaceEnv = resolve7;
+  }
+  /**
+   * The variables a task's agent gets from its workspace. What cannot be
+   * applied is said once — silently starting without them is how agents ran
+   * under the wrong account when an edited `.envrc` was left unallowed.
+   */
+  async envForTask(cwd) {
+    const resolved = await this.workspaceEnv(cwd);
+    const warn = (key, message) => {
+      if (this.envWarnings.has(key)) return;
+      this.envWarnings.add(key);
+      this.notifications.warn(message);
+    };
+    if (resolved.blockedEnvrc) {
+      warn(`blocked:${resolved.blockedEnvrc}`, `direnv has blocked ${resolved.blockedEnvrc}, so tasks start without its variables. Run \`direnv allow\` in ${path11.dirname(resolved.blockedEnvrc)} to use them.`);
+    }
+    if (resolved.trackedEnvFile) {
+      warn(`tracked:${resolved.trackedEnvFile}`, `Ignored ${resolved.trackedEnvFile}: git tracks it, and a committed file must not choose the environment agents run in. Untrack it to use it.`);
+    }
+    if (resolved.refused.length > 0) {
+      warn(`refused:${resolved.refused.join(",")}`, `Ignored ${resolved.refused.join(", ")} from the workspace environment: Ordewell never passes these to agents.`);
+    }
+    return resolved.env;
+  }
   setRegistry(registry) {
     this.registry = registry;
   }
@@ -8415,7 +8949,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 +8958,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 +8994,62 @@ 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) {
+    this.closeLingeringOf(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 });
+    this.closeLingeringOf(this.requireRun());
+    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 });
+    this.closeLingeringOf(this.requireRun());
+    await this.isolation.discard(this.requireRun(), { integration: "delete" });
+    this.forgetRun();
+  }
+  watchBlockingPrompts(task, attempt, session) {
+    const manifest = this.registry?.get(attempt.runner)?.manifest;
+    watchBlockingPrompts(session, manifest?.runner.blockingPrompts ?? [], (prompt) => {
+      if (this.attempts.get(task.id) !== attempt) return;
+      this.notifications.warn(`Task "${task.title}" is waiting for you: ${manifest?.displayName ?? attempt.runner} is asking ${prompt.asks}. Answer it in the task's terminal.`);
+    });
+  }
+  closeLingering(taskId) {
+    const sessionId = this.lingering.get(taskId);
+    if (sessionId === void 0) return;
+    this.lingering.delete(taskId);
+    this.terminalRunner.stop(sessionId);
+  }
+  closeLingeringOf(run) {
+    for (const taskId of Object.keys(run.tasks)) this.closeLingering(taskId);
+  }
+  forgetRun() {
     this.isolationRun = null;
     this.resolvers = {};
     this.emit("onIsolationChanged");
@@ -8513,7 +9085,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";
@@ -8563,17 +9136,25 @@ var TaskOrchestrator = class {
     if (!await this.openRun(() => this.start()) || this.running) return;
     console.log(`[TaskOrchestrator] Starting with ${this.store.allTasks.length} tasks (${this.store.allTasks.filter((t) => t.type === "ai" && t.prompt).length} AI ready)`);
     this.running = true;
+    this.haltedByFailure = false;
     this.planStatus = "running";
     this.emit("onTaskChanged");
     await this.tick();
   }
+  haltOnFailure() {
+    if (this.running) this.haltedByFailure = true;
+    this.running = false;
+    this.planStatus = "approved";
+  }
   stop() {
+    this.haltedByFailure = false;
     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 +9170,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;
@@ -8602,13 +9184,15 @@ ${summary || "(empty \u2014 no output captured)"}`);
       await this.landPassed(task, landing);
     } else {
       this.store.markFailed(taskId);
-      this.running = false;
-      this.planStatus = "approved";
+      this.haltOnFailure();
       this.notifications.error(`Task "${task.title}" failed verification: ${verdict.reason}`);
       if (attempt.worktree) await this.releaseWorktree(taskId, { keep: true });
     }
     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 +9205,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,18 +9303,44 @@ ${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;
-      this.planStatus = "approved";
+      this.haltOnFailure();
       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
@@ -8700,6 +9375,7 @@ ${summary || "(empty \u2014 no output captured)"}`);
     await integration;
     const run = this.isolationRun;
     if (!run?.tasks[taskId]) return;
+    if (!opts.keep) this.closeLingering(taskId);
     try {
       await this.isolation.release(run, taskId, opts);
     } catch (err) {
@@ -8848,7 +9524,8 @@ ${summary || "(empty \u2014 no output captured)"}`);
     this.onHold.delete(taskId);
     this.emit("onTaskChanged");
     await this.releaseWorktree(taskId, { keep: false }, ended?.integration);
-    await this.tick();
+    if (this.haltedByFailure && !this.running) await this.start();
+    else await this.tick();
   }
   /**
    * Manually start a single AI task right now, bypassing dependency/readiness
@@ -8955,6 +9632,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,13 +9643,16 @@ ${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()
       });
+      this.closeLingering(task.id);
+      const env = await this.envForTask(cwd);
       const session = await this.terminalRunner.spawn({
         taskId: task.id,
         runner: attempt.runner,
@@ -8983,18 +9664,30 @@ ${summary || "(empty \u2014 no output captured)"}`);
         cwd,
         registry: this.registry ?? void 0,
         order: task.order,
-        title: task.title
+        title: task.title,
+        env
       });
-      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.watchBlockingPrompts(task, attempt, 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 +9701,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 +9817,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 +9841,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);
@@ -9184,6 +9905,7 @@ ${summary || "(empty \u2014 no output captured)"}`);
     const attempt = this.attempts.get(taskId);
     this.attempts.delete(taskId);
     if (attempt) this.output.detach(taskId);
+    if (reason === "verdict" && attempt?.session) this.lingering.set(taskId, attempt.session.id);
     if (reason === "cancel" || reason === "release" || reason === "complete" || reason === "retry") {
       const task = this.store.get(taskId);
       if (task) this.verifier.clear(task);
@@ -9192,9 +9914,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,29 +10048,29 @@ ${errors.map((e) => `- ${e}`).join("\n")}`
 };
 
 // src/services/ModelDiscovery.ts
-import * as path11 from "path";
+import * as path14 from "path";
 import { exec as exec3, spawn } from "child_process";
 import { promisify as promisify3 } from "util";
 import * as fsSync3 from "fs";
 import * as osMod from "os";
 
 // src/utils/globalDataDir.ts
-import * as fs5 from "fs";
-import * as path9 from "path";
-import * as os4 from "os";
+import * as fs6 from "fs";
+import * as path12 from "path";
+import * as os5 from "os";
 function globalDataDir() {
-  return path9.join(os4.homedir(), ".ordewell");
+  return path12.join(os5.homedir(), ".ordewell");
 }
 function copyDirSync(src, dest) {
-  fs5.mkdirSync(dest, { recursive: true });
-  const entries = fs5.readdirSync(src, { withFileTypes: true });
+  fs6.mkdirSync(dest, { recursive: true });
+  const entries = fs6.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 = path12.join(src, entry.name);
+    const destPath = path12.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirSync(srcPath, destPath);
     } else {
-      fs5.copyFileSync(srcPath, destPath);
+      fs6.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -9354,50 +10078,29 @@ var migrated = false;
 function migrateOldConfigDir() {
   if (migrated) return;
   migrated = true;
-  const oldDir = path9.join(os4.homedir(), ".config", "ordewell");
-  if (!fs5.existsSync(oldDir)) return;
+  const oldDir = path12.join(os5.homedir(), ".config", "ordewell");
+  if (!fs6.existsSync(oldDir)) return;
   const newDir = globalDataDir();
   const liftFile = (name) => {
-    const oldFile = path9.join(oldDir, name);
-    const newFile = path9.join(newDir, name);
-    if (fs5.existsSync(oldFile) && !fs5.existsSync(newFile)) {
-      fs5.mkdirSync(newDir, { recursive: true });
-      fs5.copyFileSync(oldFile, newFile);
+    const oldFile = path12.join(oldDir, name);
+    const newFile = path12.join(newDir, name);
+    if (fs6.existsSync(oldFile) && !fs6.existsSync(newFile)) {
+      fs6.mkdirSync(newDir, { recursive: true });
+      fs6.copyFileSync(oldFile, newFile);
     }
   };
   liftFile("settings.json");
   liftFile(".env");
-  const oldPlugins = path9.join(oldDir, "plugins");
-  const newPlugins = path9.join(newDir, "plugins");
-  if (fs5.existsSync(oldPlugins) && !fs5.existsSync(newPlugins)) {
+  const oldPlugins = path12.join(oldDir, "plugins");
+  const newPlugins = path12.join(newDir, "plugins");
+  if (fs6.existsSync(oldPlugins) && !fs6.existsSync(newPlugins)) {
     copyDirSync(oldPlugins, newPlugins);
   }
 }
 
 // src/utils/launch.ts
 import * as fsSync2 from "fs";
-import * as path10 from "path";
-
-// src/utils/shell.ts
-var ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]|\x1b\][^\x07]*\x07|\x1b[()][AB012]|\r/g;
-function stripAnsi(text) {
-  return text.replace(ANSI_RE, "");
-}
-function posixShellQuote(s) {
-  return `'${s.replace(/'/g, `'\\''`)}'`;
-}
-function buildShellInvocation(command, args) {
-  const inner = [command, ...args].map(posixShellQuote).join(" ");
-  return { shellPath: "/bin/bash", shellArgs: ["-lc", inner] };
-}
-function wrapWithPty(command, args, opts = {}) {
-  const inner = [command, ...args].map(posixShellQuote).join(" ");
-  const watcher = opts.controlChannel ? 'exec 4<&0; ( while read -r C R <&3; do stty cols "$C" rows "$R" <&4; done ) & ' : "";
-  const setup = opts.size ? `stty cols ${opts.size.cols} rows ${opts.size.rows}; ` : "";
-  return { command: "script", args: ["-q", "-e", "-f", "-c", `${watcher}${setup}${inner}`, "/dev/null"] };
-}
-
-// src/utils/launch.ts
+import * as path13 from "path";
 var DIRECT_EXTENSIONS = [".exe", ".com"];
 var BATCH_EXTENSIONS = [".cmd", ".bat"];
 var POWERSHELL_EXTENSIONS = [".ps1"];
@@ -9405,7 +10108,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 ? path13.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 +10160,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(path13.delimiter).map((d) => d.trim()).filter(Boolean).some((dir) => exists(path13.join(dir, command)));
 }
 function isExecutableResolved(command, plan, PATH, deps = {}) {
   if ((deps.platform ?? process.platform) === "win32") return plan.file !== command;
@@ -9497,9 +10200,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(path13.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 = path13.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 +10223,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 = path13.win32.basename(command) !== command ? [path13.win32.dirname(path13.win32.resolve(command))] : (await (deps.resolvePath ?? augmentedPath)() || "").split(path13.win32.delimiter).map((d) => d.trim().replace(/^"|"$/g, "")).filter(Boolean);
+  const base = path13.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 = path13.win32.join(dir, `${base}${ext}`);
         if (exists(candidate)) {
           found.push({ file: candidate, route });
           break outer;
@@ -9572,10 +10275,10 @@ async function planShellLaunch(command, args, deps = {}) {
 }
 
 // src/utils/processTree.ts
-import { execFile as execFile2 } from "child_process";
+import { execFile as execFile3 } from "child_process";
 var HARD_KILL_DELAY_MS = 5e3;
 function defaultExecFile2(file, args, cb) {
-  execFile2(file, args, (err) => cb(err ?? null));
+  execFile3(file, args, (err) => cb(err ?? null));
 }
 function killTree(proc, deps = {}) {
   if (!proc || proc.killed || typeof proc.exitCode === "number") return;
@@ -9621,7 +10324,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((resolve7) => {
     let child;
     try {
       child = spawn(launch.file, launch.args, {
@@ -9630,7 +10333,7 @@ var defaultAppServerClient = async (command, args, options) => {
         windowsVerbatimArguments: launch.verbatim
       });
     } catch {
-      resolve5(null);
+      resolve7(null);
       return;
     }
     let settled = false;
@@ -9639,7 +10342,7 @@ var defaultAppServerClient = async (command, args, options) => {
       settled = true;
       clearTimeout(timer);
       killTree(child);
-      resolve5(value);
+      resolve7(value);
     };
     const timer = setTimeout(() => finish(null), options?.timeout ?? 2e4);
     child.on("error", () => finish(null));
@@ -9706,7 +10409,7 @@ function geminiDiscoveryCacheKey(apiKey) {
   return {
     key: `gemini-models:${hash}`,
     dir,
-    file: path11.join(dir, `gemini_models_${hash}.json`)
+    file: path14.join(dir, `gemini_models_${hash}.json`)
   };
 }
 function readGeminiCache(apiKey) {
@@ -10229,8 +10932,8 @@ var ModelDiscovery = class {
 };
 
 // src/services/ModelCatalog.ts
-import * as fs6 from "fs";
-import * as path12 from "path";
+import * as fs7 from "fs";
+import * as path15 from "path";
 var CACHE_KEY = "model-catalog";
 var CACHE_TTL_MS = 60 * 60 * 1e3;
 function storageKey(baseUrl) {
@@ -10282,17 +10985,17 @@ 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`);
-      if (fs6.existsSync(cacheFile)) fs6.rmSync(cacheFile);
+      const cacheFile = path15.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
+      if (fs7.existsSync(cacheFile)) fs7.rmSync(cacheFile);
     } catch {
     }
   }
   static readCache(key) {
     try {
       const cacheDir = globalCacheDir();
-      const cacheFile = path12.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
-      if (!fs6.existsSync(cacheFile)) return null;
-      const raw = fs6.readFileSync(cacheFile, "utf8");
+      const cacheFile = path15.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
+      if (!fs7.existsSync(cacheFile)) return null;
+      const raw = fs7.readFileSync(cacheFile, "utf8");
       const data = JSON.parse(raw);
       if (Date.now() - data.cachedAt > CACHE_TTL_MS) return null;
       return JSON.stringify(data.models);
@@ -10303,9 +11006,9 @@ var ModelCatalog = class {
   static writeCache(key, models) {
     try {
       const cacheDir = globalCacheDir();
-      fs6.mkdirSync(cacheDir, { recursive: true });
-      const cacheFile = path12.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
-      fs6.writeFileSync(
+      fs7.mkdirSync(cacheDir, { recursive: true });
+      const cacheFile = path15.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
+      fs7.writeFileSync(
         cacheFile,
         JSON.stringify({ models, cachedAt: Date.now() }, null, 2)
       );
@@ -10681,71 +11384,12 @@ var RunnerInstallation = class {
   }
 };
 
-// src/services/settingsEnvAllowlist.ts
-var ORDEWELL_SETTABLE_ENV = [
-  "AI_PROVIDER",
-  "ORCHESTRATOR_MODEL",
-  "ORDEWELL_SUBAGENT_MODEL",
-  "ORDEWELL_PLANNER_EFFORT",
-  "ORDEWELL_RESEARCH_ENABLED",
-  "ORDEWELL_MAX_PARALLEL"
-];
-var SETTINGS_ENV_REFUSED = [
-  // Approval posture and pre-approved scope.
-  "ORDEWELL_AUTONOMOUS_MODE",
-  "ORDEWELL_APPROVAL_MODE",
-  "ORDEWELL_APPROVAL_ALLOW",
-  // Where settings are persisted.
-  "ORDEWELL_SETTINGS_PATH",
-  // Runtime options and dynamic loaders.
-  "NODE_OPTIONS",
-  "NODE_REPL_EXTERNAL_MODULE",
-  "NODE_PATH",
-  "ELECTRON_RUN_AS_NODE",
-  "LD_PRELOAD",
-  "LD_LIBRARY_PATH",
-  "LD_AUDIT",
-  "DYLD_INSERT_LIBRARIES",
-  "DYLD_LIBRARY_PATH",
-  "DYLD_FRAMEWORK_PATH",
-  // Executable resolution.
-  "PATH",
-  "PATHEXT",
-  "NODE"
-];
-var REFUSED = new Set(SETTINGS_ENV_REFUSED);
-function providerEnvKeys() {
-  const keys = [];
-  for (const meta of Object.values(ALL_PROVIDERS)) {
-    if (meta.apiKeyEnvVar) keys.push(meta.apiKeyEnvVar);
-    if (meta.baseUrlEnvVar) keys.push(meta.baseUrlEnvVar);
-    for (const detect of meta.detectEnvVars) keys.push(detect);
-  }
-  return keys;
-}
-var PROVIDER_CREDENTIAL_ENV = new Set(providerEnvKeys());
-var SETTINGS_ENV_ALLOWLIST = new Set(
-  [...providerEnvKeys(), ...ORDEWELL_SETTABLE_ENV].filter((key) => !REFUSED.has(key))
-);
-function admitSettingsEnv(env) {
-  const accepted = {};
-  const rejected = [];
-  for (const [key, value] of Object.entries(env)) {
-    if (REFUSED.has(key) || !SETTINGS_ENV_ALLOWLIST.has(key) || typeof value !== "string") {
-      rejected.push(key);
-      continue;
-    }
-    accepted[key] = value;
-  }
-  return { accepted, rejected };
-}
-
 // src/services/harness/CliAgentAiService.ts
 import { spawn as nodeSpawn } from "child_process";
 
 // src/utils/workspace.ts
-import * as fs7 from "fs";
-import * as path13 from "path";
+import * as fs8 from "fs";
+import * as path16 from "path";
 var WorkspaceNotFoundError = class extends Error {
   constructor(workspace) {
     super(`Workspace "${workspace}" does not exist.`);
@@ -10756,7 +11400,7 @@ var WorkspaceNotFoundError = class extends Error {
 };
 function defaultIsDirectory(candidate) {
   try {
-    return fs7.statSync(candidate).isDirectory();
+    return fs8.statSync(candidate).isDirectory();
   } catch {
     return false;
   }
@@ -10792,8 +11436,8 @@ var PROJECT_MARKER_FILES = [
   "CMakeLists.txt"
 ];
 function assertWorkspaceIsProject(workspace, deps = {}) {
-  const realpath = deps.realpath ?? ((candidate) => fs7.realpathSync(candidate));
-  const exists = deps.exists ?? ((candidate) => fs7.existsSync(candidate));
+  const realpath = deps.realpath ?? ((candidate) => fs8.realpathSync(candidate));
+  const exists = deps.exists ?? ((candidate) => fs8.existsSync(candidate));
   let resolved;
   try {
     resolved = realpath(workspace);
@@ -10801,7 +11445,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(path16.join(resolved, marker2))
   );
   if (!hasMarker) throw new WorkspaceNotAProjectError(workspace);
 }
@@ -10869,13 +11513,14 @@ 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((resolve7) => {
+      this.markEnded = resolve7;
     });
     const spec = this.spawnSpec(opts);
     const resolvePath = this.deps.resolvePath ?? augmentedPath;
     const PATH = await resolvePath();
-    this.spawnEnv = withPath(process.env, PATH, spec.env);
+    const workspace = await (this.deps.workspaceEnv ?? workspaceEnvOf)(opts.cwd);
+    this.spawnEnv = withPath(process.env, PATH, { ...workspace, ...spec.env });
     const launch = await planDirectLaunch(spec.command, spec.args, {
       platform: this.deps.platform,
       resolvePath
@@ -10921,7 +11566,7 @@ ${err.message}`).slice(-STDERR_TAIL_CHARS);
       onEvent({ type: "error", message: this.exitMessage() });
       return;
     }
-    await new Promise((resolve5) => {
+    await new Promise((resolve7) => {
       let settled = false;
       const finish = () => {
         if (settled) return;
@@ -10932,7 +11577,7 @@ ${err.message}`).slice(-STDERR_TAIL_CHARS);
         signal?.removeEventListener("abort", onAbort);
         this.process?.removeListener("exit", onExit);
         this.process?.removeListener("error", onExit);
-        resolve5();
+        resolve7();
       };
       const emit = (event) => {
         onEvent(event);
@@ -11147,14 +11792,14 @@ function codexSandboxUnavailableMessage() {
   ].join("\n");
 }
 function runProbe(deps, cwd, env, flags) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve7) => {
     let output = "";
     let settled = false;
     const finish = (code) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve5({ code, output });
+      resolve7({ code, output });
     };
     const timer = setTimeout(() => finish(null), PROBE_TIMEOUT_MS);
     timer.unref?.();
@@ -11237,8 +11882,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((resolve7) => {
+      this.settleHandshake = resolve7;
     });
     this.writeLine({
       jsonrpc: "2.0",
@@ -11251,8 +11896,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((resolve7) => {
+        const t = setTimeout(() => resolve7(false), HANDSHAKE_TIMEOUT_MS);
         t.unref?.();
       })
     ]);
@@ -11529,12 +12174,12 @@ function describeError(err) {
   return lines.join(": ");
 }
 function delay(ms, signal) {
-  return new Promise((resolve5) => {
-    const timer = setTimeout(resolve5, ms);
+  return new Promise((resolve7) => {
+    const timer = setTimeout(resolve7, ms);
     timer.unref?.();
     signal?.addEventListener("abort", () => {
       clearTimeout(timer);
-      resolve5();
+      resolve7();
     }, { once: true });
   });
 }
@@ -11568,17 +12213,17 @@ var OpenCodeAdapter = class {
       throw new ExecutableNotFoundError("opencode", PATH);
     }
     this.process = this.deps.spawn(launch.file, launch.args, {
-      env: withPath(process.env, PATH),
+      env: withPath(process.env, PATH, await (this.deps.workspaceEnv ?? workspaceEnvOf)(opts.cwd)),
       stdio: ["pipe", "pipe", "pipe"],
       cwd: opts.cwd,
       windowsVerbatimArguments: launch.verbatim
     });
-    const banner = new Promise((resolve5) => {
+    const banner = new Promise((resolve7) => {
       let seen = "";
       const scan = (chunk) => {
         seen += chunk.toString();
         const match = seen.match(/https?:\/\/[^\s]+/);
-        if (match) resolve5(match[0].replace(/[.,)]$/, ""));
+        if (match) resolve7(match[0].replace(/[.,)]$/, ""));
       };
       this.process.stdout?.on("data", scan);
       this.process.stderr?.on("data", (chunk) => {
@@ -11587,15 +12232,15 @@ var OpenCodeAdapter = class {
       });
       this.process.on("exit", () => {
         this.exited = true;
-        resolve5(null);
+        resolve7(null);
       });
       this.process.on("error", (err) => {
         this.exited = true;
         this.stderrTail = (this.stderrTail + `
 ${err.message}`).slice(-STDERR_TAIL_CHARS2);
-        resolve5(null);
+        resolve7(null);
       });
-      const timer = setTimeout(() => resolve5(null), SERVER_READY_TIMEOUT_MS);
+      const timer = setTimeout(() => resolve7(null), SERVER_READY_TIMEOUT_MS);
       timer.unref?.();
     });
     this.baseUrl = await banner;
@@ -11628,8 +12273,8 @@ ${this.stderrTail.trim()}` : ""}`);
     const streamAbort = new AbortController();
     let connected = () => {
     };
-    const streamReady = new Promise((resolve5) => {
-      connected = resolve5;
+    const streamReady = new Promise((resolve7) => {
+      connected = resolve7;
     });
     const live = this.streamEvents(
       streamAbort.signal,
@@ -11833,14 +12478,14 @@ ${part.text}` : part.text });
       }
     }
   }
-  async json(method, path22, body, signal) {
-    const response = await this.deps.fetch(`${this.baseUrl}${path22}`, {
+  async json(method, path25, body, signal) {
+    const response = await this.deps.fetch(`${this.baseUrl}${path25}`, {
       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} ${path25} failed: ${response.status} ${response.statusText}`);
     return await response.json().catch(() => null);
   }
   nativeSessionId() {
@@ -12294,8 +12939,8 @@ var CliAgentAiService = class {
       this.lastNativeSessionId = previousSessionId;
     }
   }
-  async researchAndPlan(userDescription, runners, modelsByRunner, fs14, onProgress, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
-    const contextStr = await collectResearchContext(fs14, runners);
+  async researchAndPlan(userDescription, runners, modelsByRunner, fs15, onProgress, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+    const contextStr = await collectResearchContext(fs15, runners);
     const researchLog = [
       { id: `up-${Date.now()}`, type: "user_prompt", content: userDescription, timestamp: (/* @__PURE__ */ new Date()).toISOString() }
     ];
@@ -12509,33 +13154,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 +13232,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 });
@@ -13196,25 +13839,25 @@ function retargetTaskRunner(task, runner, catalog) {
 }
 
 // src/services/SkillsService.ts
-import * as fs8 from "fs";
-import * as path15 from "path";
+import * as fs9 from "fs";
+import * as path18 from "path";
 
 // src/services/builtinSkills.ts
-import * as path14 from "path";
+import * as path17 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 : path17.dirname(fileURLToPath(
     // @ts-expect-error - import.meta is only valid under an ESM module setting
     import.meta.url
   ));
-  return path14.join(dir, "..", "skills");
+  return path17.join(dir, "..", "skills");
 }
 
 // src/services/SkillsService.ts
 var BUILTIN_SKILL_NAMES = ["grilling", "to-spec", "improve-codebase-architecture"];
 var RETIRED_BUILTIN_SKILL_NAMES = ["grill-me"];
 function parseSkillFile(filePath, name, source) {
-  const raw = fs8.readFileSync(filePath, "utf8");
+  const raw = fs9.readFileSync(filePath, "utf8");
   const frontmatter = {};
   let content = raw;
   if (raw.startsWith("---\n")) {
@@ -13243,23 +13886,23 @@ function parseSkillFile(filePath, name, source) {
   return { name, description: metadata.description, metadata, content, path: filePath, source };
 }
 function copyDirSync2(src, dest) {
-  fs8.mkdirSync(dest, { recursive: true });
-  const entries = fs8.readdirSync(src, { withFileTypes: true });
+  fs9.mkdirSync(dest, { recursive: true });
+  const entries = fs9.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 = path18.join(src, entry.name);
+    const destPath = path18.join(dest, entry.name);
     if (entry.isDirectory()) copyDirSync2(srcPath, destPath);
-    else fs8.copyFileSync(srcPath, destPath);
+    else fs9.copyFileSync(srcPath, destPath);
   }
 }
 function readDir(dir, source) {
-  if (!fs8.existsSync(dir)) return [];
-  const entries = fs8.readdirSync(dir, { withFileTypes: true });
+  if (!fs9.existsSync(dir)) return [];
+  const entries = fs9.readdirSync(dir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const skillFile = path15.join(dir, entry.name, "SKILL.md");
-    if (!fs8.existsSync(skillFile)) continue;
+    const skillFile = path18.join(dir, entry.name, "SKILL.md");
+    if (!fs9.existsSync(skillFile)) continue;
     const parsed = parseSkillFile(skillFile, entry.name, source);
     if (parsed) skills.push(parsed);
   }
@@ -13271,22 +13914,22 @@ var SkillsService = class {
   }
   workspaceRoot;
   localDir() {
-    return this.workspaceRoot ? path15.join(this.workspaceRoot, ".ordewell", "skills") : void 0;
+    return this.workspaceRoot ? path18.join(this.workspaceRoot, ".ordewell", "skills") : void 0;
   }
   globalDir() {
-    return path15.join(globalDataDir(), "skills");
+    return path18.join(globalDataDir(), "skills");
   }
   seed(name) {
-    const dest = path15.join(this.globalDir(), name);
-    if (fs8.existsSync(dest)) return false;
+    const dest = path18.join(this.globalDir(), name);
+    if (fs9.existsSync(dest)) return false;
     let srcDir;
     try {
-      srcDir = path15.join(builtinSkillsDir(), name);
+      srcDir = path18.join(builtinSkillsDir(), name);
     } catch (err) {
       console.warn(`Could not locate built-in skills dir: ${String(err)}`);
       return false;
     }
-    if (!fs8.existsSync(srcDir)) {
+    if (!fs9.existsSync(srcDir)) {
       console.warn(`Built-in skill not found in package: ${name}`);
       return false;
     }
@@ -13300,14 +13943,14 @@ var SkillsService = class {
   isUnmodifiedRetiredSeed(dir, expectedName) {
     let entries;
     try {
-      entries = fs8.readdirSync(dir, { withFileTypes: true });
+      entries = fs9.readdirSync(dir, { withFileTypes: true });
     } catch {
       return false;
     }
     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 = fs9.readFileSync(path18.join(dir, "SKILL.md"), "utf8");
     } catch {
       return false;
     }
@@ -13324,11 +13967,11 @@ var SkillsService = class {
   }
   pruneRetired() {
     for (const name of RETIRED_BUILTIN_SKILL_NAMES) {
-      const dest = path15.join(this.globalDir(), name);
-      if (!fs8.existsSync(dest)) continue;
+      const dest = path18.join(this.globalDir(), name);
+      if (!fs9.existsSync(dest)) continue;
       if (!this.isUnmodifiedRetiredSeed(dest, name)) continue;
       try {
-        fs8.rmSync(dest, { recursive: true, force: true });
+        fs9.rmSync(dest, { recursive: true, force: true });
       } catch (err) {
         console.warn(`Could not prune retired skill ${name}: ${String(err)}`);
       }
@@ -13339,11 +13982,11 @@ 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");
-      if (fs8.existsSync(localFile)) return parseSkillFile(localFile, name, "local");
+      const localFile = path18.join(localDir, name, "SKILL.md");
+      if (fs9.existsSync(localFile)) return parseSkillFile(localFile, name, "local");
     }
-    const globalFile = path15.join(this.globalDir(), name, "SKILL.md");
-    if (fs8.existsSync(globalFile)) return parseSkillFile(globalFile, name, "global");
+    const globalFile = path18.join(this.globalDir(), name, "SKILL.md");
+    if (fs9.existsSync(globalFile)) return parseSkillFile(globalFile, name, "global");
     return void 0;
   }
   listSkills() {
@@ -13370,8 +14013,8 @@ function createSkillsService(workspaceRoot) {
 }
 
 // src/utils/sessionStore.ts
-import * as fs9 from "fs";
-import * as path16 from "path";
+import * as fs10 from "fs";
+import * as path19 from "path";
 
 // src/utils/sessionId.ts
 import { randomBytes as randomBytes2 } from "crypto";
@@ -13382,7 +14025,7 @@ function mintSessionId() {
 // src/utils/sessionStore.ts
 var SESSIONS_SUBDIR = "sessions";
 function getSessionsDir(baseDir) {
-  return path16.join(getStateDir(baseDir), SESSIONS_SUBDIR);
+  return path19.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,11 +14047,11 @@ 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 = path19.join(sessionsDir, legacySessionFilename(meta));
+  if (legacy === path19.join(sessionsDir, sessionFilename(meta)) || !fs10.existsSync(legacy)) return;
   try {
-    const held = JSON.parse(fs9.readFileSync(legacy, "utf-8")).meta?.id;
-    if (held === meta.id) fs9.unlinkSync(legacy);
+    const held = JSON.parse(fs10.readFileSync(legacy, "utf-8")).meta?.id;
+    if (held === meta.id) fs10.unlinkSync(legacy);
   } catch {
   }
 }
@@ -13431,18 +14074,18 @@ function saveSession(plan, goal, baseDir, id) {
     plan: JSON.parse(JSON.stringify(plan))
   };
   const filename = sessionFilename(meta);
-  const filePath = path16.join(sessionsDir, filename);
-  fs9.writeFileSync(filePath, JSON.stringify(session, null, 2));
+  const filePath = path19.join(sessionsDir, filename);
+  fs10.writeFileSync(filePath, JSON.stringify(session, null, 2));
   dropLegacyFile(sessionsDir, meta);
   return meta;
 }
 function listSessions(baseDir, logger = defaultLogger) {
   const sessionsDir = getSessionsDir(baseDir);
-  if (!fs9.existsSync(sessionsDir)) return [];
-  const files = fs9.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
+  if (!fs10.existsSync(sessionsDir)) return [];
+  const files = fs10.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
   return files.map((f) => {
     try {
-      const raw = fs9.readFileSync(path16.join(sessionsDir, f), "utf-8");
+      const raw = fs10.readFileSync(path19.join(sessionsDir, f), "utf-8");
       const parsed = JSON.parse(raw);
       if (hasScalarRunner(parsed)) {
         logger.warn("sessionStore", `session file ${f}: ${REJECTION_MESSAGE}`);
@@ -13457,10 +14100,10 @@ function listSessions(baseDir, logger = defaultLogger) {
   }).filter((m) => m !== null).sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
 }
 function findSessionFile(sessionsDir, sessionId, logger) {
-  const files = fs9.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
+  const files = fs10.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 = fs10.readFileSync(path19.join(sessionsDir, f), "utf-8");
       const session = JSON.parse(raw);
       if (session.meta.id === sessionId) return f;
     } catch (err) {
@@ -13471,11 +14114,11 @@ function findSessionFile(sessionsDir, sessionId, logger) {
 }
 function loadSession(sessionId, baseDir, logger = defaultLogger) {
   const sessionsDir = getSessionsDir(baseDir);
-  if (!fs9.existsSync(sessionsDir)) return null;
+  if (!fs10.existsSync(sessionsDir)) return null;
   try {
     const file = findSessionFile(sessionsDir, sessionId, logger);
     if (file) {
-      const raw = fs9.readFileSync(path16.join(sessionsDir, file), "utf-8");
+      const raw = fs10.readFileSync(path19.join(sessionsDir, file), "utf-8");
       const parsed = JSON.parse(raw);
       if (hasScalarRunner(parsed)) {
         logger.warn("sessionStore", `session file ${file}: ${REJECTION_MESSAGE}`);
@@ -13506,11 +14149,11 @@ function getLatestSession(baseDir, logger = defaultLogger) {
 }
 function deleteSession(sessionId, baseDir, logger = defaultLogger) {
   const sessionsDir = getSessionsDir(baseDir);
-  if (!fs9.existsSync(sessionsDir)) return false;
+  if (!fs10.existsSync(sessionsDir)) return false;
   try {
     const file = findSessionFile(sessionsDir, sessionId, logger);
     if (file) {
-      fs9.unlinkSync(path16.join(sessionsDir, file));
+      fs10.unlinkSync(path19.join(sessionsDir, file));
       return true;
     }
   } catch (err) {
@@ -14042,26 +14685,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.
    */
@@ -14187,6 +14834,10 @@ var Session = class {
     }
     await this.orchestrator.runTask(taskId);
   }
+  /** Start whatever the scheduler can now fit — after the parallel limit was raised mid-run, say. */
+  async reschedule() {
+    await this.orchestrator.tick();
+  }
   async retryTask(taskId) {
     await this.orchestrator.retryTask(taskId);
     this.persist();
@@ -14334,8 +14985,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;
@@ -15066,7 +15718,7 @@ var HeadlessRunner = class extends AbstractRunner {
     return {
       launch: await planDirectLaunch(command, args, this.launchDeps),
       resolvedPath,
-      env: invocation.env,
+      env: { ...opts.env, ...invocation.env },
       pty,
       submitPromptKey: invocation.submitPromptKey
     };
@@ -15085,11 +15737,11 @@ var HeadlessRunner = class extends AbstractRunner {
 };
 
 // src/services/TmuxRunner.ts
-import { execFile as execFile3 } from "child_process";
+import { execFile as execFile4 } 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 join17 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync8, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "fs";
 
 // src/utils/tmux.ts
 import { execSync as execSync2 } from "child_process";
@@ -15140,7 +15792,7 @@ function clipboardCopyCommand(hasBin = defaultHasBin, platform = process.platfor
 
 // src/services/TmuxRunner.ts
 var EXIT_RE = /<<<ORDEWELL_TMUX_EXIT:(\d+)>>>/;
-var execFileAsync2 = promisify5(execFile3);
+var execFileAsync2 = promisify5(execFile4);
 var defaultExecFile3 = async (command, args) => {
   const { stdout, stderr } = await execFileAsync2(command, args);
   return { stdout: String(stdout), stderr: String(stderr) };
@@ -15196,7 +15848,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) ? readFileSync8(this.logPath, "utf8") : "";
     } catch {
       return;
     }
@@ -15375,10 +16027,10 @@ var TmuxRunner = class extends AbstractRunner {
       windowName,
       this.execFileImpl,
       this.pollIntervalMs,
-      join15(this.logDir, `${id}.log`),
+      join17(this.logDir, `${id}.log`),
       this.socket
     );
-    invocation.env = { ...invocation.env, PATH: await this.resolvePath() };
+    invocation.env = { ...opts.env, ...invocation.env, PATH: await this.resolvePath() };
     await session.start(invocation.command, invocation.args, opts.cwd, invocation.env);
     if (invocation.submitPromptKey) session.write("\r");
     this.registerSession(id, session);
@@ -15388,8 +16040,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 readFileSync9, unlinkSync as unlinkSync3, writeSync } from "fs";
+import { join as join18 } from "path";
 var BEARER_PREFIX = "bearer ";
 var DAEMON_TOKEN_SUBPROTOCOL_PREFIX = "ordewell.token.";
 var DAEMON_SUBPROTOCOL = "ordewell.v1";
@@ -15397,12 +16049,12 @@ function configDir() {
   return globalDataDir();
 }
 function daemonTokenPath(port) {
-  return join16(configDir(), `server-${port}.token`);
+  return join18(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 +16069,7 @@ function mintDaemonToken(port) {
 }
 function readDaemonToken(port) {
   try {
-    const token = readFileSync7(daemonTokenPath(port), "utf8").trim();
+    const token = readFileSync9(daemonTokenPath(port), "utf8").trim();
     return token === "" ? void 0 : token;
   } catch {
     return void 0;
@@ -15458,18 +16110,18 @@ function tokensMatch(presented, expected) {
 }
 
 // src/plugins/RunnerRegistry.ts
-import * as fs11 from "fs";
-import * as path19 from "path";
-import * as os5 from "os";
+import * as fs12 from "fs";
+import * as path22 from "path";
+import * as os6 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 fs11 from "fs";
+import * as path21 from "path";
 
 // src/plugins/pluginNames.ts
-import * as path17 from "path";
+import * as path20 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 +16136,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 = path20.resolve(pluginsDir);
+  const dest = path20.resolve(root, name);
+  const relative5 = path20.relative(root, dest);
+  if (relative5 !== name || relative5 === "" || path20.isAbsolute(relative5)) {
     throw new Error(`Plugin install path escapes the plugins directory: ${JSON.stringify(name)}`);
   }
   return dest;
@@ -15502,13 +16154,13 @@ function isValidManifest(obj) {
 
 // src/plugins/FsPluginStore.ts
 function userPluginsDir() {
-  return path18.join(globalDataDir(), "plugins");
+  return path21.join(globalDataDir(), "plugins");
 }
 function loadManifestFromDir(dir) {
-  const manifestPath = path18.join(dir, "manifest.json");
-  if (!fs10.existsSync(manifestPath)) return null;
+  const manifestPath = path21.join(dir, "manifest.json");
+  if (!fs11.existsSync(manifestPath)) return null;
   try {
-    const raw = fs10.readFileSync(manifestPath, "utf8");
+    const raw = fs11.readFileSync(manifestPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!isValidManifest(parsed)) return null;
     return parsed;
@@ -15518,29 +16170,29 @@ function loadManifestFromDir(dir) {
 }
 function copyDirSync3(src, dest) {
   ensureDir(dest);
-  const entries = fs10.readdirSync(src, { withFileTypes: true });
+  const entries = fs11.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 = path21.join(src, entry.name);
+    const destPath = path21.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirSync3(srcPath, destPath);
     } else {
-      fs10.copyFileSync(srcPath, destPath);
+      fs11.copyFileSync(srcPath, destPath);
     }
   }
 }
 function rmDirSync(dir) {
-  if (!fs10.existsSync(dir)) return;
-  const entries = fs10.readdirSync(dir, { withFileTypes: true });
+  if (!fs11.existsSync(dir)) return;
+  const entries = fs11.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const p = path18.join(dir, entry.name);
+    const p = path21.join(dir, entry.name);
     if (entry.isDirectory()) {
       rmDirSync(p);
     } else {
-      fs10.unlinkSync(p);
+      fs11.unlinkSync(p);
     }
   }
-  fs10.rmdirSync(dir);
+  fs11.rmdirSync(dir);
 }
 var FsPluginStore = class {
   getUserPluginsDir() {
@@ -15548,10 +16200,10 @@ var FsPluginStore = class {
   }
   listUserPluginDirs() {
     const dir = userPluginsDir();
-    if (!fs10.existsSync(dir)) return [];
+    if (!fs11.existsSync(dir)) return [];
     let entries;
     try {
-      entries = fs10.readdirSync(dir, { withFileTypes: true });
+      entries = fs11.readdirSync(dir, { withFileTypes: true });
     } catch {
       return [];
     }
@@ -15559,7 +16211,7 @@ var FsPluginStore = class {
   }
   listDir(dir) {
     try {
-      return fs10.readdirSync(dir);
+      return fs11.readdirSync(dir);
     } catch {
       return [];
     }
@@ -15577,20 +16229,20 @@ var FsPluginStore = class {
     ensureDir(dir);
   }
   writeFile(filePath, content) {
-    fs10.writeFileSync(filePath, content);
+    fs11.writeFileSync(filePath, content);
   }
   readFile(filePath) {
     try {
-      return fs10.readFileSync(filePath, "utf8");
+      return fs11.readFileSync(filePath, "utf8");
     } catch {
       return null;
     }
   }
-  dirExists(path22) {
-    return fs10.existsSync(path22) && fs10.statSync(path22).isDirectory();
+  dirExists(path25) {
+    return fs11.existsSync(path25) && fs11.statSync(path25).isDirectory();
   }
-  exists(path22) {
-    return fs10.existsSync(path22);
+  exists(path25) {
+    return fs11.existsSync(path25);
   }
 };
 
@@ -15617,7 +16269,15 @@ var CLAUDE_CODE_MANIFEST = {
       "{{/if}}",
       "{{prompt}}"
     ],
-    promptInArgs: true
+    promptInArgs: true,
+    // Interactive sessions show these even with --dangerously-skip-permissions:
+    // a folder Claude Code has never been trusted in (a fresh clone, or a repo
+    // only ever planned in headlessly), and the first Bypass Permissions run.
+    blockingPrompts: [
+      { phrase: "Is this a project you created or one you trust", asks: "whether to trust the task's folder" },
+      { phrase: "Do you trust the files in this folder", asks: "whether to trust the task's folder" },
+      { phrase: "running in Bypass Permissions mode", asks: "you to accept Bypass Permissions mode" }
+    ]
   },
   features: {
     modelSelection: true,
@@ -16022,7 +16682,7 @@ var RunnerRegistry = class {
     return entry?.source === "builtin";
   }
   installFromPath(sourcePath) {
-    const absPath = path19.resolve(sourcePath);
+    const absPath = path22.resolve(sourcePath);
     if (!this.store.dirExists(absPath)) {
       throw new Error(`Plugin source must be a directory: ${absPath}`);
     }
@@ -16034,7 +16694,7 @@ var RunnerRegistry = class {
   }
   installFromGit(url) {
     const validated = assertInstallablePluginUrl(url);
-    const tmpDir = path19.join(os5.tmpdir(), `ordewell-plugin-${randomBytes4(12).toString("hex")}`);
+    const tmpDir = path22.join(os6.tmpdir(), `ordewell-plugin-${randomBytes4(12).toString("hex")}`);
     this.store.ensureDir(tmpDir);
     try {
       try {
@@ -16047,7 +16707,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 ? path22.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 +16755,7 @@ var RunnerRegistry = class {
   }
   createSkeleton(name, outputDir) {
     assertPlainPluginName(name);
-    const dir = path19.resolve(outputDir, name);
+    const dir = path22.resolve(outputDir, name);
     this.store.ensureDir(dir);
     const manifest = {
       name,
@@ -16127,8 +16787,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(path22.join(dir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+    const runSh = path22.join(dir, "run.sh");
     const scriptContent = `#!/usr/bin/env bash
 # Custom runner script for ${name}
 # Receives:
@@ -16154,30 +16814,30 @@ echo "Running ${name} with prompt: $prompt"
 };
 function fsChmodSync(fpath, mode) {
   try {
-    fs11.chmodSync(fpath, mode);
+    fs12.chmodSync(fpath, mode);
   } catch {
   }
 }
 
 // src/utils/stateStore.ts
-import * as fs12 from "fs";
-import * as path20 from "path";
+import * as fs13 from "fs";
+import * as path23 from "path";
 var STATE_FILE = "state.json";
 function getStatePath(baseDir) {
-  return path20.join(getStateDir(baseDir), STATE_FILE);
+  return path23.join(getStateDir(baseDir), STATE_FILE);
 }
 function saveState(plan, baseDir) {
   const statePath = getStatePath(baseDir ?? process.cwd());
-  ensureDir(path20.dirname(statePath));
+  ensureDir(path23.dirname(statePath));
   plan.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-  fs12.writeFileSync(statePath, JSON.stringify(plan, null, 2));
+  fs13.writeFileSync(statePath, JSON.stringify(plan, null, 2));
 }
 function loadState(baseDir, logger = defaultLogger) {
   const dir = baseDir ?? process.cwd();
   const statePath = getStatePath(dir);
-  if (!fs12.existsSync(statePath)) return null;
+  if (!fs13.existsSync(statePath)) return null;
   try {
-    const raw = fs12.readFileSync(statePath, "utf-8");
+    const raw = fs13.readFileSync(statePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.runners)) {
       logger.warn("stateStore", `rejecting state from ${statePath}: old format (scalar "runner" instead of "runners" array). Please re-plan.`);
@@ -16194,16 +16854,16 @@ function loadState(baseDir, logger = defaultLogger) {
 function clearState(baseDir) {
   const dir = baseDir ?? process.cwd();
   const statePath = getStatePath(dir);
-  if (fs12.existsSync(statePath)) fs12.unlinkSync(statePath);
+  if (fs13.existsSync(statePath)) fs13.unlinkSync(statePath);
 }
 function stateExists(baseDir) {
   const dir = baseDir ?? process.cwd();
-  return fs12.existsSync(getStatePath(dir));
+  return fs13.existsSync(getStatePath(dir));
 }
 
 // src/services/SettingsService.ts
-import * as fs13 from "fs";
-import * as path21 from "path";
+import * as fs14 from "fs";
+import * as path24 from "path";
 var DEFAULTS = {
   tdd: { enabled: true },
   verification: { enabled: false }
@@ -16211,7 +16871,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 path24.join(globalDataDir(), "settings.json");
 }
 function readPlannerModels(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
@@ -16244,7 +16904,7 @@ var SettingsService = class {
   }
   fileMtimeMs() {
     try {
-      return fs13.statSync(this.filePath).mtimeMs;
+      return fs14.statSync(this.filePath).mtimeMs;
     } catch {
       return null;
     }
@@ -16316,8 +16976,8 @@ var SettingsService = class {
   load() {
     migrateOldConfigDir();
     try {
-      if (fs13.existsSync(this.filePath)) {
-        const raw = JSON.parse(fs13.readFileSync(this.filePath, "utf-8"));
+      if (fs14.existsSync(this.filePath)) {
+        const raw = JSON.parse(fs14.readFileSync(this.filePath, "utf-8"));
         const settings = {
           tdd: { enabled: raw.tdd?.enabled ?? DEFAULTS.tdd.enabled },
           verification: { enabled: raw.verification?.enabled ?? DEFAULTS.verification.enabled }
@@ -16339,11 +16999,11 @@ var SettingsService = class {
     return { ...DEFAULTS, tdd: { ...DEFAULTS.tdd }, verification: { ...DEFAULTS.verification } };
   }
   persist() {
-    const dir = path21.dirname(this.filePath);
-    if (!fs13.existsSync(dir)) {
-      fs13.mkdirSync(dir, { recursive: true });
+    const dir = path24.dirname(this.filePath);
+    if (!fs14.existsSync(dir)) {
+      fs14.mkdirSync(dir, { recursive: true });
     }
-    fs13.writeFileSync(this.filePath, JSON.stringify(this.cache, null, 2));
+    fs14.writeFileSync(this.filePath, JSON.stringify(this.cache, null, 2));
     this.cachedMtimeMs = this.fileMtimeMs();
   }
 };
@@ -16409,6 +17069,7 @@ export {
   ConversationEditError,
   DAEMON_SUBPROTOCOL,
   DAEMON_TOKEN_SUBPROTOCOL_PREFIX,
+  DEFAULT_MAX_PARALLEL,
   DENY_ALL,
   EmbeddedNewlineError,
   EnvConfig,
@@ -16482,6 +17143,7 @@ export {
   augmentPromptWithPriorOutputs,
   augmentedPath,
   bearerHeaderValue,
+  buildConflictRepairPrompt,
   buildConflictResolutionPrompt,
   buildConversationSystemPrompt,
   buildFallbackGrepArgs,
@@ -16501,6 +17163,7 @@ export {
   canMergeTasks,
   canSetDependencies,
   canSplitTask,
+  capConflictFiles,
   checkDepsResolve,
   checkImmutableLog,
   checkInProgress,
@@ -16589,6 +17252,7 @@ export {
   modifyValidationFeedback,
   normalizeAgentArgs,
   normalizeGeminiModel,
+  parseMaxParallel,
   parsePartialPlan,
   parsePlanJson,
   parseTaskOpsJson,