@ordewell/core 0.11.2 → 0.11.3

package/dist/index.mjs

@@ -4358,7 +4358,7 @@ function pathRefs(command, opts = {}) {
   return lexAll(command.trim(), dialect, opts.cdpathSet).segments.flatMap((seg) => {
     const patterns = patternArgs(seg);
     const cwd = seg.cwd ?? [];
-    return [...seg.args.filter((_, i) => !patterns.has(i)), ...seg.inputs].flatMap(pathIn).map((path47) => ({ path: path47, cwd }));
+    return [...seg.args.filter((_, i) => !patterns.has(i)), ...seg.inputs].flatMap(pathIn).map((path49) => ({ path: path49, cwd }));
   });
 }
 function excludedBy(command, allow, opts = {}) {
@@ -6442,7 +6442,7 @@ ${outcome.output}${outcome.success ? "" : `
     }
     let shell;
     try {
-      const sealed = site.task?.gitBefore ? { ...site.sealed, gitEntries: site.task.gitBefore.entries.map(({ path: path47, directory }) => ({ path: path47, directory })) } : site.sealed;
+      const sealed = site.task?.gitBefore ? { ...site.sealed, gitEntries: site.task.gitBefore.entries.map(({ path: path49, directory }) => ({ path: path49, directory })) } : site.sealed;
       shell = await site.sandbox.launchSealed(this.researchShell, sealed);
     } catch (err) {
       return { refused: refusal(`Command not run: its sealed sandbox could not be prepared (${err instanceof Error ? err.message : String(err)}).`) };
@@ -8225,9 +8225,9 @@ function claudeManagedSettingsDir(platform = process.platform) {
 }
 function readClaudeSettingsModels(files, platform = process.platform) {
   const managed = claudeManagedSettingsDir(platform);
-  const join43 = platform === "win32" ? path12.win32.join : path12.posix.join;
-  const dropIns = files.list(join43(managed, "managed-settings.d")).filter((name) => name.endsWith(".json") && !name.startsWith(".")).sort().map((name) => join43(managed, "managed-settings.d", name));
-  const ranked = [...dropIns.reverse(), join43(managed, "managed-settings.json"), join43(claudeConfigDir(files.env), "settings.json")];
+  const join45 = platform === "win32" ? path12.win32.join : path12.posix.join;
+  const dropIns = files.list(join45(managed, "managed-settings.d")).filter((name) => name.endsWith(".json") && !name.startsWith(".")).sort().map((name) => join45(managed, "managed-settings.d", name));
+  const ranked = [...dropIns.reverse(), join45(managed, "managed-settings.json"), join45(claudeConfigDir(files.env), "settings.json")];
   for (const file of ranked) {
     const content = files.read(file);
     const lineup = content === null ? null : parseClaudeSettingsModels(content);
@@ -9088,12 +9088,12 @@ function checkpointReply(answer2) {
       return { text: `The checkpoint was withdrawn: ${answer2.why}`, isError: true };
   }
 }
-function fieldPath(path47) {
-  return path47.reduce((text4, part) => typeof part === "number" ? `${text4}[${part}]` : text4 ? `${text4}.${String(part)}` : String(part), "");
+function fieldPath(path49) {
+  return path49.reduce((text4, part) => typeof part === "number" ? `${text4}[${part}]` : text4 ? `${text4}.${String(part)}` : String(part), "");
 }
-function valueAt(value, path47) {
+function valueAt(value, path49) {
   let current = value;
-  for (const part of path47) {
+  for (const part of path49) {
     if (typeof part === "number") {
       if (!Array.isArray(current)) return void 0;
       current = current[part];
@@ -9115,7 +9115,7 @@ function boundedRefusal(issue, args) {
 var LEAKED_PARAMETER = /<\/parameter>|<parameter\s+name\s*=\s*"([^"]*)">/g;
 function leakedMarkupIn(value) {
   const found = [];
-  const walk = (node, path47) => {
+  const walk = (node, path49) => {
     if (typeof node === "string") {
       const names = [];
       let closing = false;
@@ -9123,25 +9123,25 @@ function leakedMarkupIn(value) {
         if (match[1] !== void 0) names.push(match[1]);
         else closing = true;
       }
-      if (names.length > 0 || closing) found.push({ path: path47, names: [...new Set(names)], closing });
+      if (names.length > 0 || closing) found.push({ path: path49, names: [...new Set(names)], closing });
       return;
     }
     if (Array.isArray(node)) {
-      node.forEach((item, i) => walk(item, `${path47}[${i}]`));
+      node.forEach((item, i) => walk(item, `${path49}[${i}]`));
       return;
     }
     if (node !== null && typeof node === "object") {
-      for (const [key, item] of Object.entries(node)) walk(item, path47 ? `${path47}.${key}` : key);
+      for (const [key, item] of Object.entries(node)) walk(item, path49 ? `${path49}.${key}` : key);
     }
   };
   walk(value, "");
   return found;
 }
 function markupRefusal(leaks) {
-  return leaks.map(({ path: path47, names, closing }) => {
+  return leaks.map(({ path: path49, names, closing }) => {
     const tags = [...names.map((n) => `<parameter name="${n}">`), ...closing ? ["</parameter>"] : []];
-    const guide = names.length > 0 ? ` The parameters ${names.map((n) => JSON.stringify(n)).join(", ")} are inside it; pass them as separate arguments, not inside ${path47}.` : " Pass each argument separately, not inside one string.";
-    return `${path47} contains leaked tool-call markup: ${tags.join(", ")}.${guide}`;
+    const guide = names.length > 0 ? ` The parameters ${names.map((n) => JSON.stringify(n)).join(", ")} are inside it; pass them as separate arguments, not inside ${path49}.` : " Pass each argument separately, not inside one string.";
+    return `${path49} contains leaked tool-call markup: ${tags.join(", ")}.${guide}`;
   }).join("\n");
 }
 function invalidArguments(name, error, args) {
@@ -9606,9 +9606,9 @@ function mcpClientConfig(credential) {
 }
 function ownerOnlyConfigFile(fileName, contents) {
   const dir = mkdtempSync2(join9(tmpdir2(), "ordewell-mcp-"));
-  const path47 = join9(dir, fileName);
-  writeFileSync(path47, contents, { mode: 384 });
-  return { path: path47, remove: () => rmSync2(dir, { recursive: true, force: true }) };
+  const path49 = join9(dir, fileName);
+  writeFileSync(path49, contents, { mode: 384 });
+  return { path: path49, remove: () => rmSync2(dir, { recursive: true, force: true }) };
 }
 
 // src/services/harness/repoConfig.ts
@@ -9737,33 +9737,33 @@ var TomlReader = class {
       if (this.i >= this.src.length) return root;
       if (this.src.startsWith("[[", this.i)) {
         this.i += 2;
-        const path47 = this.key();
+        const path49 = this.key();
         this.expect("]]");
-        const parent = this.tableAt(root, path47.slice(0, -1));
-        const last = path47[path47.length - 1];
+        const parent = this.tableAt(root, path49.slice(0, -1));
+        const last = path49[path49.length - 1];
         const list = Object.hasOwn(parent, last) ? parent[last] : parent[last] = [];
-        if (!Array.isArray(list)) throw this.fail(`${path47.join(".")} is not an array of tables`);
+        if (!Array.isArray(list)) throw this.fail(`${path49.join(".")} is not an array of tables`);
         table = newTable();
         list.push(table);
       } else if (this.src[this.i] === "[") {
         this.i += 1;
-        const path47 = this.key();
+        const path49 = this.key();
         this.expect("]");
-        table = this.tableAt(root, path47);
+        table = this.tableAt(root, path49);
       } else {
-        const path47 = this.key();
+        const path49 = this.key();
         this.skipBlank(false);
         this.expect("=");
         this.skipBlank(false);
-        const owner = this.tableAt(table, path47.slice(0, -1));
-        owner[path47[path47.length - 1]] = this.value();
+        const owner = this.tableAt(table, path49.slice(0, -1));
+        owner[path49[path49.length - 1]] = this.value();
       }
       this.endOfLine();
     }
   }
-  tableAt(from, path47) {
+  tableAt(from, path49) {
     let table = from;
-    for (const part of path47) {
+    for (const part of path49) {
       const next = Object.hasOwn(table, part) ? table[part] : void 0;
       if (next === void 0) table = table[part] = newTable();
       else if (isRecord(next)) table = next;
@@ -9832,10 +9832,10 @@ var TomlReader = class {
         this.i++;
         return table;
       }
-      const path47 = this.key();
+      const path49 = this.key();
       this.expect("=");
       this.skipBlank(false);
-      this.tableAt(table, path47.slice(0, -1))[path47[path47.length - 1]] = this.value();
+      this.tableAt(table, path49.slice(0, -1))[path49[path49.length - 1]] = this.value();
       this.skipBlank(true);
       if (this.src[this.i] === ",") this.i++;
       else if (this.src[this.i] !== "}") throw this.fail("expected , or } in an inline table");
@@ -10210,7 +10210,7 @@ var LineBuffer = class {
 // src/services/harness/ClaudeCodeAdapter.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { realpathSync as realpathSync7 } from "fs";
-import * as path21 from "path";
+import * as path22 from "path";
 
 // src/plugins/resolveArgs.ts
 function claudeThinkingArgs(effort) {
@@ -10293,28 +10293,28 @@ function posixBinDirs() {
   ];
 }
 function windowsBinDirs(env, home) {
-  const join43 = (...parts) => path14.win32.join(...parts);
-  const under = (base, ...parts) => base ? [join43(base, ...parts)] : [];
+  const join45 = (...parts) => path14.win32.join(...parts);
+  const under = (base, ...parts) => base ? [join45(base, ...parts)] : [];
   const appData = env.APPDATA;
   const localAppData = env.LOCALAPPDATA;
   const programData = env.ProgramData;
   return [
     // Native per-user installers, PowerShell-driven and otherwise.
-    join43(home, ".local", "bin"),
-    join43(home, ".opencode", "bin"),
-    join43(home, ".claude", "bin"),
-    join43(home, ".codex", "bin"),
+    join45(home, ".local", "bin"),
+    join45(home, ".opencode", "bin"),
+    join45(home, ".claude", "bin"),
+    join45(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"),
-    join43(home, "AppData", "Roaming", "npm"),
+    join45(home, "AppData", "Roaming", "npm"),
     ...under(localAppData, "pnpm"),
     ...under(localAppData, "Yarn", "bin"),
-    join43(home, ".bun", "bin"),
+    join45(home, ".bun", "bin"),
     // Windows package managers.
-    join43(home, "scoop", "shims"),
+    join45(home, "scoop", "shims"),
     ...under(env.SCOOP, "shims"),
     ...under(env.SCOOP_GLOBAL ?? programData, "scoop", "shims"),
     ...under(programData, "chocolatey", "bin"),
@@ -10324,7 +10324,7 @@ function windowsBinDirs(env, home) {
     ...under(localAppData, "Microsoft", "WindowsApps"),
     // Version managers. Volta's Windows home is not the POSIX `~/.volta`.
     ...under(localAppData, "Volta", "bin"),
-    join43(home, ".volta", "bin")
+    join45(home, ".volta", "bin")
   ];
 }
 function wellKnownBinDirs(deps = {}) {
@@ -11572,7 +11572,7 @@ function readOnlySessionRules(site) {
       real = realpathSync4.native(root);
     } catch {
     }
-    for (const path47 of /* @__PURE__ */ new Set([root, real])) rules.push({ action: "external_directory", resource: `${path47.replace(/[\\/]$/, "")}/*`, effect: "allow" });
+    for (const path49 of /* @__PURE__ */ new Set([root, real])) rules.push({ action: "external_directory", resource: `${path49.replace(/[\\/]$/, "")}/*`, effect: "allow" });
   }
   return rules;
 }
@@ -12294,6 +12294,20 @@ ${lines.map((line) => `${line}
 }
 
 // src/services/harness/claudeOrdewell.ts
+import * as path20 from "path";
+function assertNoClaudeTaskCollision(cwd) {
+  const text4 = readText(path20.join(cwd, ".mcp.json"));
+  if (text4 === void 0) return;
+  let parsed;
+  try {
+    parsed = JSON.parse(text4);
+  } catch {
+    return;
+  }
+  if (isRecord(parsed) && isRecord(parsed.mcpServers) && Object.hasOwn(parsed.mcpServers, ORDEWELL_MCP_SERVER_NAME)) {
+    throw new Error(".mcp.json declares an MCP server named ordewell; rename or remove the ordewell server before starting this task.");
+  }
+}
 var CLAUDE_ORDEWELL = {
   toolName: MCP_CLIENT_TOOL_NAMES.toolName,
   toolNames: MCP_CLIENT_TOOL_NAMES.toolNames,
@@ -12441,8 +12455,8 @@ var ReplyRuns = class {
 };
 
 // src/services/harness/claudeRepoConfig.ts
-import * as path20 from "path";
-var MEMORY_FILES = ["CLAUDE.md", path20.join(".claude", "CLAUDE.md"), "CLAUDE.local.md"];
+import * as path21 from "path";
+var MEMORY_FILES = ["CLAUDE.md", path21.join(".claude", "CLAUDE.md"), "CLAUDE.local.md"];
 var MAX_IMPORT_DEPTH = 5;
 function importsOf(text4) {
   const prose = text4.replace(/```[\s\S]*?```/g, "").replace(/`[^`\n]*`/g, "");
@@ -12453,11 +12467,11 @@ function withImports(workspace, file, depth, seen, into) {
   seen.add(file);
   const text4 = readText(file);
   if (text4 === void 0) return;
-  into.push({ path: path20.relative(workspace, file), text: text4 });
+  into.push({ path: path21.relative(workspace, file), text: text4 });
   if (depth >= MAX_IMPORT_DEPTH) return;
   for (const target of importsOf(text4)) {
     if (target.startsWith("~")) continue;
-    const abs = path20.resolve(path20.dirname(file), target);
+    const abs = path21.resolve(path21.dirname(file), target);
     if (insideOnDisk(workspace, abs)) withImports(workspace, abs, depth + 1, seen, into);
   }
 }
@@ -12478,12 +12492,12 @@ var CLAUDE_REPO_CONFIG = {
   instructions(workspace) {
     const files = [];
     const seen = /* @__PURE__ */ new Set();
-    for (const name of MEMORY_FILES) withImports(workspace, path20.join(workspace, name), 0, seen, files);
+    for (const name of MEMORY_FILES) withImports(workspace, path21.join(workspace, name), 0, seen, files);
     return files;
   },
   projectServers(workspace) {
     const source = ".mcp.json";
-    const text4 = readText(path20.join(workspace, source));
+    const text4 = readText(path21.join(workspace, source));
     if (text4 === void 0) return NO_SERVERS;
     let parsed;
     try {
@@ -12503,12 +12517,12 @@ var CLAUDE_REPO_CONFIG = {
 };
 function claudeLocalServers(env, workspace) {
   const configDir2 = env.CLAUDE_CONFIG_DIR?.trim();
-  const file = expandRunnerHome(configDir2 ? path20.join(configDir2, ".claude.json") : "~/.claude.json", env);
+  const file = expandRunnerHome(configDir2 ? path21.join(configDir2, ".claude.json") : "~/.claude.json", env);
   const text4 = file === null ? void 0 : readText(file);
   if (text4 === void 0) return {};
   try {
     const parsed = JSON.parse(text4);
-    const project = isRecord(parsed) && isRecord(parsed.projects) ? parsed.projects[path20.resolve(workspace)] : void 0;
+    const project = isRecord(parsed) && isRecord(parsed.projects) ? parsed.projects[path21.resolve(workspace)] : void 0;
     return isRecord(project) && isRecord(project.mcpServers) ? project.mcpServers : {};
   } catch {
     return {};
@@ -12763,13 +12777,13 @@ var NO_AUTO_MEMORY = { CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1" };
 function inSavedOutput(abs, configDir2, sessionId) {
   let projects;
   try {
-    projects = realpathSync7.native(path21.join(configDir2, "projects"));
+    projects = realpathSync7.native(path22.join(configDir2, "projects"));
   } catch {
     return false;
   }
-  const rel = path21.relative(projects, abs);
-  if (rel.startsWith("..") || path21.isAbsolute(rel)) return false;
-  const [project, session, folder] = rel.split(path21.sep);
+  const rel = path22.relative(projects, abs);
+  if (rel.startsWith("..") || path22.isAbsolute(rel)) return false;
+  const [project, session, folder] = rel.split(path22.sep);
   return Boolean(project) && session === sessionId && folder === "tool-results";
 }
 var PATH_TOOLS = {
@@ -13060,6 +13074,7 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
    */
   taskSpawnSpec(opts) {
     const readOnly = readOnlyTask(opts);
+    if (!readOnly) assertNoClaudeTaskCollision(opts.cwd);
     this.readOnlySite = readOnly ? opts : null;
     this.requestedMode = readOnly ? PLANNER_PERMISSION_MODE : opts.flags.permissionMode;
     this.followedModel = opts.model;
@@ -13855,8 +13870,8 @@ function runProbe(deps, cwd, env, flags) {
 }
 
 // src/services/harness/codexRepoConfig.ts
-import * as path22 from "path";
-var CONFIG_FILE = path22.join(".codex", "config.toml");
+import * as path23 from "path";
+var CONFIG_FILE = path23.join(".codex", "config.toml");
 function stringsOf(value) {
   return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
 }
@@ -13882,9 +13897,9 @@ var CODEX_REPO_CONFIG = {
     const files = [];
     for (const dir of repoLevels(workspace)) {
       for (const name of ["AGENTS.override.md", "AGENTS.md"]) {
-        const text4 = readText(path22.join(dir, name));
+        const text4 = readText(path23.join(dir, name));
         if (text4 === void 0) continue;
-        files.push({ path: path22.relative(workspace, path22.join(dir, name)) || name, text: text4 });
+        files.push({ path: path23.relative(workspace, path23.join(dir, name)) || name, text: text4 });
         break;
       }
     }
@@ -13895,10 +13910,10 @@ var CODEX_REPO_CONFIG = {
     const byName = /* @__PURE__ */ new Map();
     const unreadable = [];
     for (const dir of repoLevels(workspace)) {
-      const file = path22.join(dir, CONFIG_FILE);
+      const file = path23.join(dir, CONFIG_FILE);
       const text4 = readText(file);
       if (text4 === void 0) continue;
-      const source = path22.relative(workspace, file);
+      const source = path23.relative(workspace, file);
       let parsed;
       try {
         parsed = parseToml(text4);
@@ -13918,9 +13933,9 @@ var CODEX_REPO_CONFIG = {
 };
 function untrustedProjects(workspace) {
   const projects = {};
-  for (let dir = path22.resolve(workspace); ; dir = path22.dirname(dir)) {
+  for (let dir = path23.resolve(workspace); ; dir = path23.dirname(dir)) {
     projects[dir] = { trust_level: "untrusted" };
-    if (path22.dirname(dir) === dir) return projects;
+    if (path23.dirname(dir) === dir) return projects;
   }
 }
 
@@ -15041,7 +15056,7 @@ ${this.exitMessage()}`);
       case "webSearch":
         return;
       case "fileChange": {
-        const paths = (item.changes ?? []).map((change) => change.path).filter((path47) => !!path47);
+        const paths = (item.changes ?? []).map((change) => change.path).filter((path49) => !!path49);
         this.fileChangePaths.set(item.id, paths);
         if (this.startOpts?.kind === "task") {
           for (const change of item.changes ?? []) this.announceFileChange(item.id, change, emit, subagentId);
@@ -15144,20 +15159,20 @@ ${this.exitMessage()}`);
   announceFileChange(itemId, change, emit, subagentId) {
     const rows = this.fileChangeRows.get(itemId) ?? /* @__PURE__ */ new Map();
     this.fileChangeRows.set(itemId, rows);
-    const path47 = this.shownChangePath(change);
-    const known = rows.get(path47);
+    const path49 = this.shownChangePath(change);
+    const known = rows.get(path49);
     if (known) return known;
-    const row = rows.size === 0 ? itemId : `${itemId}:${path47}`;
-    rows.set(path47, row);
-    emit({ type: "tool_call", id: row, name: changeName(change), args: { path: path47 }, ...subagentId ? { subagentId } : {} });
+    const row = rows.size === 0 ? itemId : `${itemId}:${path49}`;
+    rows.set(path49, row);
+    emit({ type: "tool_call", id: row, name: changeName(change), args: { path: path49 }, ...subagentId ? { subagentId } : {} });
     return row;
   }
   /** Relative to the task's worktree, where every path but a stray one lies; a move names both ends. */
   shownChangePath(change) {
-    const shown = (path47) => {
+    const shown = (path49) => {
       const cwd = this.startOpts?.cwd;
-      const rel = cwd ? relative8(cwd, path47) : path47;
-      return rel && rel !== ".." && !rel.startsWith(`..${sep3}`) && !isAbsolute6(rel) ? rel : path47;
+      const rel = cwd ? relative8(cwd, path49) : path49;
+      return rel && rel !== ".." && !rel.startsWith(`..${sep3}`) && !isAbsolute6(rel) ? rel : path49;
     };
     const from = shown(change.path ?? "");
     return change.kind?.move_path ? `${from} \u2192 ${shown(change.kind.move_path)}` : from;
@@ -15208,7 +15223,7 @@ import { realpathSync as realpathSync8 } from "fs";
 
 // src/services/harness/projectServers.ts
 import { createHash } from "crypto";
-import * as path23 from "path";
+import * as path24 from "path";
 function canonical2(value) {
   if (Array.isArray(value)) return value.map(canonical2);
   if (!isRecord(value)) return value;
@@ -15219,7 +15234,7 @@ function projectServerScope(server4) {
   return `mcp-server:${server4.name}@${hash}`;
 }
 var scopeName = (scope) => scope.slice(0, scope.lastIndexOf("@"));
-function fileProjectServerApprovals(file = path23.join(globalDataDir(), "project-mcp-servers.json")) {
+function fileProjectServerApprovals(file = path24.join(globalDataDir(), "project-mcp-servers.json")) {
   const load = () => {
     const text4 = readText(file);
     if (text4 === void 0) return {};
@@ -16382,8 +16397,8 @@ var OpenCodeAdapter = class extends ProcessLifecycle {
       this.v2 = new OpenCodeV2({
         version,
         nativeShell: this.nativeShell?.prefix ?? null,
-        request: (method, path47, body, signal, timeoutMs) => this.request(method, path47, body, signal, timeoutMs),
-        json: (method, path47, body, signal, timeoutMs) => this.json(method, path47, body, signal, timeoutMs),
+        request: (method, path49, body, signal, timeoutMs) => this.request(method, path49, body, signal, timeoutMs),
+        json: (method, path49, body, signal, timeoutMs) => this.json(method, path49, body, signal, timeoutMs),
         openEvents: (signal) => this.deps.fetch(`${this.baseUrl}/api/event`, { signal, headers: this.headers() }),
         processEnded: this.processEnded,
         isExited: () => this.exited,
@@ -17020,15 +17035,15 @@ var OpenCodeAdapter = class extends ProcessLifecycle {
       onActivity
     );
   }
-  async json(method, path47, body, signal, timeoutMs) {
-    const response = await this.request(method, path47, body, signal, timeoutMs);
-    if (!response.ok) throw new OpenCodeHttpError(`${method} ${path47} failed: ${response.status} ${response.statusText}`);
+  async json(method, path49, body, signal, timeoutMs) {
+    const response = await this.request(method, path49, body, signal, timeoutMs);
+    if (!response.ok) throw new OpenCodeHttpError(`${method} ${path49} failed: ${response.status} ${response.statusText}`);
     return await response.json().catch(() => null);
   }
   /** `timeoutMs` null is for a turn's own POST, which the server answers when the turn is done. */
-  request(method, path47, body, signal, timeoutMs = REQUEST_TIMEOUT_MS) {
+  request(method, path49, body, signal, timeoutMs = REQUEST_TIMEOUT_MS) {
     const deadline = withDeadline(signal, timeoutMs);
-    return this.deps.fetch(`${this.baseUrl}${path47}`, {
+    return this.deps.fetch(`${this.baseUrl}${path49}`, {
       method,
       headers: this.headers({ "content-type": "application/json" }),
       ...body === void 0 ? {} : { body: JSON.stringify(body) },
@@ -17089,8 +17104,8 @@ var OpenCodeAdapter = class extends ProcessLifecycle {
 };
 
 // src/services/harness/openCodeRepoConfig.ts
-import * as path24 from "path";
-var CONFIG_FILES = ["opencode.json", "opencode.jsonc", path24.join(".opencode", "opencode.json"), path24.join(".opencode", "opencode.jsonc")];
+import * as path25 from "path";
+var CONFIG_FILES = ["opencode.json", "opencode.jsonc", path25.join(".opencode", "opencode.json"), path25.join(".opencode", "opencode.jsonc")];
 var INSTRUCTION_NAMES = ["AGENTS.md", "CLAUDE.md", "CONTEXT.md"];
 function server3(name, entry, source) {
   if (!isRecord(entry)) return "not an object";
@@ -17109,8 +17124,8 @@ var OPENCODE_REPO_CONFIG = {
     const levels = repoLevels(workspace);
     for (const name of INSTRUCTION_NAMES) {
       const files = levels.flatMap((dir) => {
-        const text4 = readText(path24.join(dir, name));
-        return text4 === void 0 ? [] : [{ path: path24.relative(workspace, path24.join(dir, name)) || name, text: text4 }];
+        const text4 = readText(path25.join(dir, name));
+        return text4 === void 0 ? [] : [{ path: path25.relative(workspace, path25.join(dir, name)) || name, text: text4 }];
       });
       if (files.length > 0) return files;
     }
@@ -17122,10 +17137,10 @@ var OPENCODE_REPO_CONFIG = {
     const unreadable = [];
     for (const dir of repoLevels(workspace)) {
       for (const name of CONFIG_FILES) {
-        const file = path24.join(dir, name);
+        const file = path25.join(dir, name);
         const text4 = readText(file);
         if (text4 === void 0) continue;
-        const source = path24.relative(workspace, file);
+        const source = path25.relative(workspace, file);
         let parsed;
         try {
           parsed = parseJsonc(text4);
@@ -17314,7 +17329,7 @@ function knownModelId(value, optionIds, shortcuts) {
 
 // src/services/ModelCatalog.ts
 import * as fs6 from "fs";
-import * as path25 from "path";
+import * as path26 from "path";
 var CACHE_KEY = "model-catalog";
 var CACHE_TTL_MS = 60 * 60 * 1e3;
 function storageKey(baseUrl) {
@@ -17367,7 +17382,7 @@ var ModelCatalog = class {
       const url = (baseUrl || "https://openrouter.ai/api/v1").replace(/\/+$/, "");
       const key = storageKey(url);
       const cacheDir = globalCacheDir();
-      const cacheFile = path25.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
+      const cacheFile = path26.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
       if (fs6.existsSync(cacheFile)) fs6.rmSync(cacheFile);
     } catch {
     }
@@ -17375,7 +17390,7 @@ var ModelCatalog = class {
   static readCache(key) {
     try {
       const cacheDir = globalCacheDir();
-      const cacheFile = path25.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
+      const cacheFile = path26.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
       if (!fs6.existsSync(cacheFile)) return null;
       const raw = fs6.readFileSync(cacheFile, "utf8");
       const data = JSON.parse(raw);
@@ -17389,7 +17404,7 @@ var ModelCatalog = class {
     try {
       const cacheDir = globalCacheDir();
       fs6.mkdirSync(cacheDir, { recursive: true });
-      const cacheFile = path25.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
+      const cacheFile = path26.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
       fs6.writeFileSync(
         cacheFile,
         JSON.stringify({ models, cachedAt: Date.now() }, null, 2)
@@ -17400,7 +17415,7 @@ var ModelCatalog = class {
 };
 
 // src/services/ModelDiscovery.ts
-import * as path26 from "path";
+import * as path27 from "path";
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
 import * as fsSync5 from "fs";
@@ -17546,7 +17561,7 @@ function geminiDiscoveryCacheKey(apiKey) {
   return {
     key: `gemini-models:${hash}`,
     dir,
-    file: path26.join(dir, `gemini_models_${hash}.json`)
+    file: path27.join(dir, `gemini_models_${hash}.json`)
   };
 }
 function readGeminiCache(apiKey) {
@@ -18054,7 +18069,7 @@ function parseMaxParallel(value) {
 
 // src/services/SettingsService.ts
 import * as fs12 from "fs";
-import * as path33 from "path";
+import * as path34 from "path";
 
 // src/utils/fileLock.ts
 import * as fs7 from "fs";
@@ -18658,33 +18673,33 @@ ${skillBlock(entry.skill)}`, timestamp: entry.timestamp });
 }
 
 // src/services/taskSkills.ts
-import * as path32 from "path";
+import * as path33 from "path";
 
 // src/services/SkillsService.ts
 import { createHash as createHash2 } from "crypto";
 import * as fs11 from "fs";
-import * as path31 from "path";
+import * as path32 from "path";
 
 // src/services/builtinSkills.ts
-import * as path27 from "path";
+import * as path28 from "path";
 import { fileURLToPath } from "url";
 function builtinSkillsDir() {
-  const dir = typeof __dirname !== "undefined" && __dirname ? __dirname : path27.dirname(fileURLToPath(
+  const dir = typeof __dirname !== "undefined" && __dirname ? __dirname : path28.dirname(fileURLToPath(
     // @ts-expect-error - import.meta is only valid under an ESM module setting
     import.meta.url
   ));
-  return path27.join(dir, "..", "skills");
+  return path28.join(dir, "..", "skills");
 }
 
 // src/services/repoGroup.ts
 import * as fs10 from "fs";
-import * as path30 from "path";
+import * as path31 from "path";
 
 // src/services/worktreeBootstrap.ts
 import { exec as exec3 } from "child_process";
 import { promisify as promisify4 } from "util";
 import * as fs9 from "fs";
-import * as path29 from "path";
+import * as path30 from "path";
 
 // src/services/gitExec.ts
 import { execFile as execFile4 } from "child_process";
@@ -18766,7 +18781,7 @@ function subcommandOf2(args) {
 
 // src/services/worktreeLink.ts
 import * as fs8 from "fs";
-import * as path28 from "path";
+import * as path29 from "path";
 function linkPath(source, target, platform, hardLink = fs8.linkSync) {
   const isDir = fs8.statSync(source).isDirectory();
   if (platform !== "win32") {
@@ -18791,8 +18806,8 @@ function mirrorDir(source, target, opts) {
   const mirror = (from, to, prefix, top) => {
     fs8.mkdirSync(to, { recursive: true });
     for (const entry of fs8.readdirSync(from, { withFileTypes: true })) {
-      const name = path28.join(prefix, entry.name);
-      const at = { from: path28.join(from, entry.name), to: path28.join(to, entry.name), name };
+      const name = path29.join(prefix, entry.name);
+      const at = { from: path29.join(from, entry.name), to: path29.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);
@@ -18812,16 +18827,16 @@ function mirrorDir(source, target, opts) {
 }
 function relink(from, to, opts) {
   const text4 = fs8.readlinkSync(from);
-  const pointee = path28.isAbsolute(text4) ? rebased(text4, opts) : text4;
+  const pointee = path29.isAbsolute(text4) ? rebased(text4, opts) : text4;
   if (opts.platform !== "win32") {
-    if (!fs8.existsSync(path28.resolve(path28.dirname(to), pointee)) && fs8.existsSync(path28.resolve(path28.dirname(from), pointee))) {
-      fs8.symlinkSync(rebased(path28.resolve(path28.dirname(from), pointee), opts), to);
+    if (!fs8.existsSync(path29.resolve(path29.dirname(to), pointee)) && fs8.existsSync(path29.resolve(path29.dirname(from), pointee))) {
+      fs8.symlinkSync(rebased(path29.resolve(path29.dirname(from), pointee), opts), to);
       return "symlink";
     }
     fs8.symlinkSync(pointee, to);
     return "symlink";
   }
-  const resolved = fs8.existsSync(path28.resolve(path28.dirname(to), pointee)) ? path28.resolve(path28.dirname(to), pointee) : rebased(path28.resolve(path28.dirname(from), pointee), opts);
+  const resolved = fs8.existsSync(path29.resolve(path29.dirname(to), pointee)) ? path29.resolve(path29.dirname(to), pointee) : rebased(path29.resolve(path29.dirname(from), pointee), opts);
   try {
     fs8.statSync(resolved);
   } catch {
@@ -18830,9 +18845,9 @@ function relink(from, to, opts) {
   return linkPath(resolved, to, opts.platform, opts.hardLink);
 }
 function rebased(pointee, opts) {
-  const rel = path28.relative(opts.from, pointee);
-  const inside2 = rel !== "" && !rel.startsWith("..") && !path28.isAbsolute(rel);
-  return inside2 && !rel.split(/[\\/]/).includes("node_modules") ? path28.join(opts.to, rel) : pointee;
+  const rel = path29.relative(opts.from, pointee);
+  const inside2 = rel !== "" && !rel.startsWith("..") && !path29.isAbsolute(rel);
+  return inside2 && !rel.split(/[\\/]/).includes("node_modules") ? path29.join(opts.to, rel) : pointee;
 }
 
 // src/services/worktreeBootstrap.ts
@@ -18869,18 +18884,18 @@ function matchLinks(root, patterns) {
 }
 function segmentMatches(root, base, segment) {
   const under = (name) => base ? `${base}/${name}` : name;
-  if (!/[*?]/.test(segment)) return lexists(path29.join(root, base, segment)) ? [under(segment)] : [];
+  if (!/[*?]/.test(segment)) return lexists(path30.join(root, base, segment)) ? [under(segment)] : [];
   const pattern = new RegExp(`^${segment.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".")}$`);
-  return listDir2(path29.join(root, base)).filter((name) => !NEVER_SCANNED.has(name) && pattern.test(name)).map(under);
+  return listDir2(path30.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(path29.join(root, dir)));
+  return ["node_modules", ...packages].filter((dir) => lexists(path30.join(root, dir)));
 }
 function workspaceGlobs(root) {
   let manifest;
   try {
-    manifest = JSON.parse(fs9.readFileSync(path29.join(root, "package.json"), "utf8"));
+    manifest = JSON.parse(fs9.readFileSync(path30.join(root, "package.json"), "utf8"));
   } catch {
     return [];
   }
@@ -18895,19 +18910,19 @@ async function bootstrap(repo, cwd, opts) {
   const linked = [];
   const copied = [];
   const link = (name) => {
-    const target = path29.join(cwd, name);
+    const target = path30.join(cwd, name);
     if (lexists(target)) return;
-    fs9.mkdirSync(path29.dirname(target), { recursive: true });
-    if (linkPath(path29.join(repo.root, name), target, opts.platform) === "copy") copied.push(name);
+    fs9.mkdirSync(path30.dirname(target), { recursive: true });
+    if (linkPath(path30.join(repo.root, name), target, opts.platform) === "copy") copied.push(name);
     linked.push(name);
   };
   const mirror = (name) => {
-    const target = path29.join(cwd, name);
-    if (lexists(target) || !fs9.existsSync(path29.dirname(target))) return;
-    const source = path29.join(repo.root, name);
+    const target = path30.join(cwd, name);
+    if (lexists(target) || !fs9.existsSync(path30.dirname(target))) return;
+    const source = path30.join(repo.root, name);
     if (!fs9.lstatSync(source).isDirectory()) return link(name);
     const mirrored = mirrorDir(source, target, { platform: opts.platform, from: repo.root, to: cwd });
-    copied.push(...mirrored.map((entry) => path29.join(name, entry)));
+    copied.push(...mirrored.map((entry) => path30.join(name, entry)));
     linked.push(name);
   };
   if (!setup) {
@@ -18942,12 +18957,12 @@ async function runSetup(command, repo, cwd, resolvePath) {
 
 // src/services/repoGroup.ts
 function hasGitEntry(dir) {
-  return fs10.existsSync(path30.join(dir, ".git"));
+  return fs10.existsSync(path31.join(dir, ".git"));
 }
 function groupPathOf(listed3) {
   const slashed = listed3.trim().replace(/\\/g, "/");
-  if (path30.posix.isAbsolute(slashed) || path30.win32.isAbsolute(slashed)) return null;
-  const rel = path30.posix.normalize(slashed).replace(/\/+$/, "");
+  if (path31.posix.isAbsolute(slashed) || path31.win32.isAbsolute(slashed)) return null;
+  const rel = path31.posix.normalize(slashed).replace(/\/+$/, "");
   return rel === "" || rel === "." || rel === ".." || rel.startsWith("../") ? null : rel;
 }
 function childDirs(dir) {
@@ -18958,14 +18973,14 @@ function childDirs(dir) {
   }
 }
 function groupPaths(workspaceRoot, listed3) {
-  if (listed3.length === 0) return childDirs(workspaceRoot).filter((name) => hasGitEntry(path30.join(workspaceRoot, name)));
-  const paths = listed3.map(groupPathOf).filter((rel) => rel !== null && hasGitEntry(path30.join(workspaceRoot, rel)));
+  if (listed3.length === 0) return childDirs(workspaceRoot).filter((name) => hasGitEntry(path31.join(workspaceRoot, name)));
+  const paths = listed3.map(groupPathOf).filter((rel) => rel !== null && hasGitEntry(path31.join(workspaceRoot, rel)));
   return [...new Set(paths)].sort();
 }
 function workspaceRepoGroup(workspaceRoot, listed3) {
-  for (let dir = path30.resolve(workspaceRoot); ; dir = path30.dirname(dir)) {
+  for (let dir = path31.resolve(workspaceRoot); ; dir = path31.dirname(dir)) {
     if (hasGitEntry(dir)) return [SELF_REPO];
-    if (path30.dirname(dir) === dir) break;
+    if (path31.dirname(dir) === dir) break;
   }
   return groupPaths(workspaceRoot, listed3);
 }
@@ -19046,8 +19061,8 @@ function copyDirSync(src, dest) {
   fs11.mkdirSync(dest, { recursive: true });
   const entries = fs11.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path31.join(src, entry.name);
-    const destPath = path31.join(dest, entry.name);
+    const srcPath = path32.join(src, entry.name);
+    const destPath = path32.join(dest, entry.name);
     if (entry.isDirectory()) copyDirSync(srcPath, destPath);
     else fs11.copyFileSync(srcPath, destPath);
   }
@@ -19071,7 +19086,7 @@ function readDir(dir, source) {
   if (!fs11.existsSync(dir)) return { skills, invalid };
   for (const entry of fs11.readdirSync(dir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const skillFile = path31.join(dir, entry.name, "SKILL.md");
+    const skillFile = path32.join(dir, entry.name, "SKILL.md");
     if (!fs11.existsSync(skillFile)) continue;
     if (!isSkillName(entry.name)) {
       invalid.push({ name: entry.name, path: skillFile, source, reason: INVALID_SKILL_NAME_REASON });
@@ -19090,15 +19105,15 @@ function skillFileIn(dir, name) {
     return void 0;
   }
   if (!entries.some((entry) => entry.isDirectory() && entry.name === name)) return void 0;
-  const skillFile = path31.join(dir, name, "SKILL.md");
+  const skillFile = path32.join(dir, name, "SKILL.md");
   return fs11.existsSync(skillFile) ? skillFile : void 0;
 }
 function skillsDirOf(root) {
-  return path31.join(root, STATE_DIR, "skills");
+  return path32.join(root, STATE_DIR, "skills");
 }
 function workspaceSkillRoots(workspaceRoot, repos, checkout = workspaceRoot) {
   if (repos.length === 0 || repos.includes(SELF_REPO)) return [checkout];
-  return [workspaceRoot, ...repos.map((repo) => path31.join(checkout, repo))];
+  return [workspaceRoot, ...repos.map((repo) => path32.join(checkout, repo))];
 }
 var SkillsService = class _SkillsService {
   workspaceRoots;
@@ -19121,11 +19136,11 @@ var SkillsService = class _SkillsService {
     return this.workspaceRoots.map(skillsDirOf);
   }
   globalDir() {
-    return path31.join(globalDataDir(), "skills");
+    return path32.join(globalDataDir(), "skills");
   }
   readSeedManifest() {
     try {
-      const parsed = JSON.parse(fs11.readFileSync(path31.join(this.globalDir(), SEED_MANIFEST), "utf8"));
+      const parsed = JSON.parse(fs11.readFileSync(path32.join(this.globalDir(), SEED_MANIFEST), "utf8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         return Object.fromEntries(
           Object.entries(parsed).filter((entry) => typeof entry[1] === "string")
@@ -19141,7 +19156,7 @@ var SkillsService = class _SkillsService {
     manifest[name] = hash;
     try {
       fs11.mkdirSync(this.globalDir(), { recursive: true });
-      fs11.writeFileSync(path31.join(this.globalDir(), SEED_MANIFEST), JSON.stringify(manifest, null, 2));
+      fs11.writeFileSync(path32.join(this.globalDir(), SEED_MANIFEST), JSON.stringify(manifest, null, 2));
     } catch (err) {
       console.warn(`Could not record seeded skill ${name}: ${String(err)}`);
     }
@@ -19152,11 +19167,11 @@ var SkillsService = class _SkillsService {
     return this.readSeedManifest()[name] === currentHash || (PRIOR_BUILTIN_HASHES[name] ?? []).includes(currentHash);
   }
   seed(name) {
-    const dest = path31.join(this.globalDir(), name);
+    const dest = path32.join(this.globalDir(), name);
     const exists = fs11.existsSync(dest);
     let srcDir;
     try {
-      srcDir = path31.join(builtinSkillsDir(), name);
+      srcDir = path32.join(builtinSkillsDir(), name);
     } catch (err) {
       if (!exists) console.warn(`Could not locate built-in skills dir: ${String(err)}`);
       return false;
@@ -19165,9 +19180,9 @@ var SkillsService = class _SkillsService {
       if (!exists) console.warn(`Built-in skill not found in package: ${name}`);
       return false;
     }
-    const srcHash = fileHash(path31.join(srcDir, "SKILL.md"));
+    const srcHash = fileHash(path32.join(srcDir, "SKILL.md"));
     if (exists) {
-      const currentHash = fileHash(path31.join(dest, "SKILL.md"));
+      const currentHash = fileHash(path32.join(dest, "SKILL.md"));
       if (currentHash !== void 0 && currentHash === srcHash) {
         this.recordSeed(name, currentHash);
         return false;
@@ -19211,7 +19226,7 @@ var SkillsService = class _SkillsService {
     if (entries.length !== 1 || entries[0].name !== "SKILL.md" || !entries[0].isFile()) return false;
     let raw;
     try {
-      raw = readSkillText(path31.join(dir, "SKILL.md"));
+      raw = readSkillText(path32.join(dir, "SKILL.md"));
     } catch {
       return false;
     }
@@ -19219,7 +19234,7 @@ var SkillsService = class _SkillsService {
   }
   pruneRetired() {
     for (const name of RETIRED_BUILTIN_SKILL_NAMES) {
-      const dest = path31.join(this.globalDir(), name);
+      const dest = path32.join(this.globalDir(), name);
       if (!fs11.existsSync(dest)) continue;
       if (!this.isUnmodifiedRetiredSeed(dest, name)) continue;
       try {
@@ -19357,12 +19372,12 @@ var runGit = execFileWithTimeout(1e4);
 async function committedInHead(files) {
   const byDir = /* @__PURE__ */ new Map();
   for (const file of new Set(files)) {
-    const dir = path32.dirname(path32.dirname(file));
+    const dir = path33.dirname(path33.dirname(file));
     byDir.set(dir, [...byDir.get(dir) ?? [], file]);
   }
   const result = /* @__PURE__ */ new Map();
   await Promise.all([...byDir].map(async ([dir, inDir]) => {
-    const relative17 = (file) => path32.relative(dir, file).split(path32.sep).join("/");
+    const relative17 = (file) => path33.relative(dir, file).split(path33.sep).join("/");
     try {
       const { stdout } = await runGit("git", ["ls-tree", "--name-only", "HEAD", "--", ...inDir.map(relative17)], { cwd: dir, env: cleanEnv() });
       const listed3 = new Set(stdout.split("\n").map((line) => line.trim()).filter(Boolean));
@@ -19382,9 +19397,9 @@ function plannedSkillLookup(skillsAt, workspaceRoot, layout) {
     searchedDirs: () => lookup2.searchedDirs(),
     listSkills: () => lookup2.listSkills(),
     uncommitted: async (skills) => {
-      const checked = skills.filter((skill) => skill.source === "workspace" && !(readInPlace && path32.dirname(path32.dirname(skill.path)) === readInPlace));
+      const checked = skills.filter((skill) => skill.source === "workspace" && !(readInPlace && path33.dirname(path33.dirname(skill.path)) === readInPlace));
       const committed = await committedInHead(checked.map((skill) => skill.path));
-      return new Map(checked.filter((skill) => committed.get(skill.path) === false).map((skill) => [skill.path, path32.relative(workspaceRoot, path32.dirname(skill.path)).split(path32.sep).join("/")]));
+      return new Map(checked.filter((skill) => committed.get(skill.path) === false).map((skill) => [skill.path, path33.relative(workspaceRoot, path33.dirname(skill.path)).split(path33.sep).join("/")]));
     }
   };
 }
@@ -19397,13 +19412,13 @@ function checkPlanSkills(tasks, lookup2) {
 function checkTaskSkillsEdit(task2, skills, lookup2) {
   return check([{ taskId: task2.id, owner: `Task "${task2.title}"`, ...attached(skills) }], lookup2);
 }
-function subtaskEntries(op, spec, path47 = []) {
+function subtaskEntries(op, spec, path49 = []) {
   const subtasks = spec?.subtasks;
   if (!Array.isArray(subtasks)) return [];
   return subtasks.flatMap((sub, i) => {
     if (typeof sub !== "object" || sub === null) return [];
     const child = sub;
-    const at = [...path47, typeof child.title === "string" && child.title.trim() ? `"${child.title}"` : `#${i + 1}`];
+    const at = [...path49, typeof child.title === "string" && child.title.trim() ? `"${child.title}"` : `#${i + 1}`];
     return [{ op, owner: `subtask ${at.join(" > ")}`, ...attached(child.skills) }, ...subtaskEntries(op, child, at)];
   });
 }
@@ -23245,7 +23260,7 @@ var RUN_SETTING_KEYS = Object.keys(RUN_SETTING_CHECKS);
 function getSettingsPath() {
   const override = process.env.ORDEWELL_SETTINGS_PATH;
   if (override && override.trim()) return override.trim();
-  return path33.join(globalDataDir(), "settings.json");
+  return path34.join(globalDataDir(), "settings.json");
 }
 function readPlannerModels(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
@@ -23325,8 +23340,8 @@ var SettingsService = class {
    * a watch on the old one pointing at nothing.
    */
   watch(listener) {
-    const dir = path33.dirname(this.filePath);
-    const name = path33.basename(this.filePath);
+    const dir = path34.dirname(this.filePath);
+    const name = path34.basename(this.filePath);
     let seen = this.fileStamp();
     let timer;
     let dead = false;
@@ -23335,7 +23350,7 @@ var SettingsService = class {
       fs12.mkdirSync(dir, { recursive: true });
       watcher = fs12.watch(dir, (_event, changed) => {
         if (dead) return;
-        if (changed && changed !== name && changed !== path33.basename(dir)) return;
+        if (changed && changed !== name && changed !== path34.basename(dir)) return;
         clearTimeout(timer);
         timer = setTimeout(() => {
           const stamp2 = this.fileStamp();
@@ -23568,7 +23583,7 @@ var SettingsService = class {
     if (this.unreadable) {
       throw new Error(`Cannot save settings: ${this.filePath} could not be read, so it will not be overwritten. Fix or remove it and try again.`);
     }
-    const dir = path33.dirname(this.filePath);
+    const dir = path34.dirname(this.filePath);
     if (!fs12.existsSync(dir)) {
       fs12.mkdirSync(dir, { recursive: true });
     }
@@ -24085,11 +24100,11 @@ var EnvConfig = class extends BaseConfig {
 // src/services/taskDiffRead.ts
 import { createHash as createHash3 } from "crypto";
 import * as fs13 from "fs";
-import * as path34 from "path";
+import * as path35 from "path";
 import { devNull } from "os";
 var TASK_DIFF_UNAVAILABLE = "Task diff is not available for this run: no task-specific changes were recorded (shared runs cannot attribute workspace changes to one task).";
 function allowedPath(file) {
-  return file.length > 0 && !path34.isAbsolute(file) && !/^[A-Za-z]:/.test(file) && !file.split(/[\\/]/).some((part) => part === ".." || part === ".git" || part === ".ordewell");
+  return file.length > 0 && !path35.isAbsolute(file) && !/^[A-Za-z]:/.test(file) && !file.split(/[\\/]/).some((part) => part === ".." || part === ".git" || part === ".ordewell");
 }
 function stats(raw) {
   return raw.split("\0").flatMap((row) => {
@@ -24098,8 +24113,8 @@ function stats(raw) {
   });
 }
 function inside(root, target) {
-  const rel = path34.relative(root, target);
-  return rel === "" || !rel.startsWith(`..${path34.sep}`) && rel !== ".." && !path34.isAbsolute(rel);
+  const rel = path35.relative(root, target);
+  return rel === "" || !rel.startsWith(`..${path35.sep}`) && rel !== ".." && !path35.isAbsolute(rel);
 }
 function unquoted(quoted4) {
   const bytes = [];
@@ -24147,10 +24162,10 @@ function patchFiles(patch) {
   const sections = patch.toString("utf8").split(/(?<![^\n])(?=diff --git )/).filter((section) => section.startsWith("diff --git "));
   const files = /* @__PURE__ */ new Map();
   for (const section of sections) {
-    const path47 = sectionPath(section);
+    const path49 = sectionPath(section);
     const counts = sectionStats(section);
-    const earlier = files.get(path47);
-    files.set(path47, earlier ? { path: path47, section: earlier.section + section, added: summed(earlier.added, counts.added), removed: summed(earlier.removed, counts.removed) } : { path: path47, section, ...counts });
+    const earlier = files.get(path49);
+    files.set(path49, earlier ? { path: path49, section: earlier.section + section, added: summed(earlier.added, counts.added), removed: summed(earlier.removed, counts.removed) } : { path: path49, section, ...counts });
   }
   return [...files.values()];
 }
@@ -24220,11 +24235,11 @@ async function readTaskDiff(invoker, run, taskId, options) {
         files.push({ ...file, repo: repo.path, patch: () => git(reader, cwd, [...diffArgs, "--", `:(top,literal)${prefix}${file.path}`]) });
       }
       if (live2) {
-        const workspace = path34.join(entry.worktree, prefix);
+        const workspace = path35.join(entry.worktree, prefix);
         const others = await git(reader, workspace, [...common, "ls-files", "--others", "--exclude-standard", "-z", "--", "."]);
         for (const file of others.split("\0").filter((f) => allowed(f))) {
-          const full = path34.join(workspace, file);
-          if (!inside(fs13.realpathSync(workspace), fs13.realpathSync(path34.dirname(full)))) continue;
+          const full = path35.join(workspace, file);
+          if (!inside(fs13.realpathSync(workspace), fs13.realpathSync(path35.dirname(full)))) continue;
           const untracked = async (numstat) => {
             const result = await tryGit(reader, workspace, [...common, "diff", "--no-index", "--no-renames", "--no-ext-diff", "--no-textconv", ...numstat ? ["--numstat", "-z"] : [], "--", devNull, file]);
             if (!result.ok && result.code !== 1) throw new Error(result.stderr.trim() || "Could not read an untracked file diff.");
@@ -24254,11 +24269,11 @@ ${await file.patch()}`);
 import { randomBytes as randomBytes6 } from "crypto";
 import { spawnSync } from "child_process";
 import * as fs15 from "fs";
-import * as path36 from "path";
+import * as path37 from "path";
 
 // src/utils/prdStore.ts
 import * as fs14 from "fs";
-import * as path35 from "path";
+import * as path36 from "path";
 var PRD_BLOCK_RE = /<!--\s*ORDEWELL_PRD_START\s+slug="([^"]+)"\s*-->\s*([\s\S]*?)\s*<!--\s*ORDEWELL_PRD_END\s*-->/;
 function extractPrdBlock(text4) {
   const match = PRD_BLOCK_RE.exec(text4);
@@ -24272,9 +24287,9 @@ function sanitizeSlug(raw) {
   return raw.toLowerCase().replace(/[^a-z0-9-_]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
 }
 function savePrdMarkdown(workspace, slug, markdown) {
-  const dir = path35.join(workspace, ".scratch", sanitizeSlug(slug));
+  const dir = path36.join(workspace, ".scratch", sanitizeSlug(slug));
   fs14.mkdirSync(dir, { recursive: true });
-  const file = path35.join(dir, "PRD.md");
+  const file = path36.join(dir, "PRD.md");
   fs14.writeFileSync(file, markdown.endsWith("\n") ? markdown : markdown + "\n", "utf8");
   return file;
 }
@@ -24306,12 +24321,12 @@ var NESTED_REPO_DEPTH = 2;
 var GITLINK_MODE = "160000";
 var READ_ONLY = ["--no-optional-locks", "-c", "core.fsmonitor=false"];
 function isInside(parent, child) {
-  const rel = path36.relative(parent, child);
-  return rel !== "" && !rel.startsWith("..") && !path36.isAbsolute(rel);
+  const rel = path37.relative(parent, child);
+  return rel !== "" && !rel.startsWith("..") && !path37.isAbsolute(rel);
 }
 function resolvesAsNamed(base, p) {
   try {
-    return fs15.realpathSync(p) === path36.join(fs15.realpathSync(base), path36.relative(base, p));
+    return fs15.realpathSync(p) === path37.join(fs15.realpathSync(base), path37.relative(base, p));
   } catch {
     return false;
   }
@@ -24366,7 +24381,7 @@ function sameDir(a, b) {
     try {
       return fs15.realpathSync.native(p);
     } catch {
-      return path36.resolve(p);
+      return path37.resolve(p);
     }
   };
   return real(a) === real(b);
@@ -24388,7 +24403,7 @@ function clearImmutableFlags(platform, dir) {
   spawnSync("/usr/bin/chflags", ["-R", "nouchg", dir], { stdio: "ignore" });
 }
 function leftoverLinks(dir) {
-  const named3 = listDir2(dir).filter((name) => LINKED_ARTIFACTS.has(name) || isEnvFile(name) || isLink(path36.join(dir, name)));
+  const named3 = listDir2(dir).filter((name) => LINKED_ARTIFACTS.has(name) || isEnvFile(name) || isLink(path37.join(dir, name)));
   return [.../* @__PURE__ */ new Set([...named3, ...installDirs(dir)])];
 }
 function isLink(target) {
@@ -24461,7 +24476,7 @@ var GitWorktreeIsolation = class {
       const head = await this.headOf(root);
       const repo = { path: repoPath, head };
       if (scan.toplevel !== void 0) {
-        const top = path36.relative(workspaceRoot, scan.toplevel).split(path36.sep).join("/");
+        const top = path37.relative(workspaceRoot, scan.toplevel).split(path37.sep).join("/");
         if (top !== "") repo.top = top;
       }
       if (enabled && (head.kind === "branch" || head.kind === "detached")) {
@@ -24518,9 +24533,9 @@ var GitWorktreeIsolation = class {
   async nestedRepos(workspaceRoot, toplevel) {
     const found = [];
     const walk = (rel, depth) => {
-      for (const name of childDirs(path36.join(workspaceRoot, rel))) {
+      for (const name of childDirs(path37.join(workspaceRoot, rel))) {
         const child = rel ? `${rel}/${name}` : name;
-        if (hasGitEntry(path36.join(workspaceRoot, child))) found.push(child);
+        if (hasGitEntry(path37.join(workspaceRoot, child))) found.push(child);
         else if (depth < NESTED_REPO_DEPTH) walk(child, depth + 1);
       }
     };
@@ -24538,7 +24553,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", path36.join(toplevel, ".gitmodules"), "--get-regexp", "^submodule\\..*\\.path$"]);
+    const declared = await this.tryGit(workspaceRoot, ["config", "-z", "-f", path37.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(/\/+$/, ""));
@@ -24596,7 +24611,7 @@ var GitWorktreeIsolation = class {
   async acceptsWorktree(run, repo) {
     const dir = this.integrationDir(run, repo);
     ensureStateDirIgnored(run.workspaceRoot);
-    fs15.mkdirSync(path36.dirname(dir), { recursive: true });
+    fs15.mkdirSync(path37.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;
@@ -24611,12 +24626,12 @@ var GitWorktreeIsolation = class {
     if (isolated.includes(SELF_REPO)) return [];
     const shared2 = [];
     const walk = (rel) => {
-      for (const name of listDir2(path36.join(workspaceRoot, rel))) {
+      for (const name of listDir2(path37.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(path36.join(workspaceRoot, child))) shared2.push(child);
+        else if (resolves(path37.join(workspaceRoot, child))) shared2.push(child);
       }
     };
     walk("");
@@ -24656,9 +24671,9 @@ var GitWorktreeIsolation = class {
       try {
         ensureStateDirIgnored(run.workspaceRoot);
         for (const repo of run.repos) {
-          const worktree = path36.join(dir, repo.path);
+          const worktree = path37.join(dir, repo.path);
           const tip = (await this.git(repo.root, ["rev-parse", repo.integrationBranch])).trim();
-          fs15.mkdirSync(path36.dirname(worktree), { recursive: true });
+          fs15.mkdirSync(path37.dirname(worktree), { recursive: true });
           await this.git(repo.root, ["worktree", "add", "-q", "-B", branch, worktree, tip]);
           record.repos[repo.path] = { worktree, linked: [], baseRef: tip };
         }
@@ -24683,13 +24698,13 @@ var GitWorktreeIsolation = class {
             setupFailed.push({ repo: repo.path, detail: err.detail });
           }
           entry.linked = boot.linked;
-          copied.push(...boot.copied.map((name) => path36.posix.join(repo.path, name)));
+          copied.push(...boot.copied.map((name) => path37.posix.join(repo.path, name)));
         }
         for (const rel of run.shared) {
-          const source = path36.join(run.workspaceRoot, rel);
-          const target = path36.join(cwd, rel);
+          const source = path37.join(run.workspaceRoot, rel);
+          const target = path37.join(cwd, rel);
           if (!resolves(source) || lexists(target)) continue;
-          fs15.mkdirSync(path36.dirname(target), { recursive: true });
+          fs15.mkdirSync(path37.dirname(target), { recursive: true });
           if (linkPath(source, target, this.platform) === "copy") copied.push(rel);
           const entry = self ? record.repos[SELF_REPO] : void 0;
           if (entry) entry.linked.push(rel);
@@ -24721,7 +24736,7 @@ var GitWorktreeIsolation = class {
    */
   async clearLeftovers(run, task2, names) {
     const removal = noRemoval();
-    const holder = Object.values(run.tasks).find((r) => r.taskId !== task2.id && (r.branch === names.branch || path36.resolve(r.workspace) === path36.resolve(names.dir) || isInside(r.workspace, names.dir)));
+    const holder = Object.values(run.tasks).find((r) => r.taskId !== task2.id && (r.branch === names.branch || path37.resolve(r.workspace) === path37.resolve(names.dir) || isInside(r.workspace, names.dir)));
     if (holder) throw new Error(`Its worktree path or branch is held by the record of task ${holder.order} (${holder.title}); Ordewell will not remove it`);
     const found = [];
     for (const repo of run.repos) {
@@ -24731,14 +24746,14 @@ var GitWorktreeIsolation = class {
         worktree: /^worktree (.+)$/m.exec(block)?.[1],
         branch: /^branch refs\/heads\/(.+)$/m.exec(block)?.[1]
       }));
-      const at = /* @__PURE__ */ new Set([path36.join(names.dir, repo.path)]);
+      const at = /* @__PURE__ */ new Set([path37.join(names.dir, repo.path)]);
       for (const entry of registered) {
-        if (entry.worktree && entry.branch === names.branch && isInside(this.runRoot(run), path36.resolve(entry.worktree))) at.add(entry.worktree);
+        if (entry.worktree && entry.branch === names.branch && isInside(this.runRoot(run), path37.resolve(entry.worktree))) at.add(entry.worktree);
       }
-      const base = { branch: names.branch, name: path36.basename(names.dir), title: task2.title };
+      const base = { branch: names.branch, name: path37.basename(names.dir), title: task2.title };
       for (const worktree of at) {
         if (!fs15.existsSync(worktree)) continue;
-        const linked = leftoverLinks(path36.join(worktree, await this.prefixOf(repo)));
+        const linked = leftoverLinks(path37.join(worktree, await this.prefixOf(repo)));
         found.push({ repo, worktree, target: { ...base, worktree, linked } });
       }
       found.push({ repo, worktree: names.dir, target: { ...base, linked: [] } });
@@ -24831,7 +24846,7 @@ var GitWorktreeIsolation = class {
    */
   async inWorkspacePlace(repo, worktree) {
     const prefix = await this.prefixOf(repo);
-    return prefix ? path36.join(worktree, prefix) : worktree;
+    return prefix ? path37.join(worktree, prefix) : worktree;
   }
   async prefixOf(repo) {
     return (await this.git(repo.root, ["rev-parse", "--show-prefix"])).trim();
@@ -25361,15 +25376,15 @@ var GitWorktreeIsolation = class {
     return landingMessage(kind, from, this.deps.plannedWith?.() ?? false);
   }
   integrationDir(run, repo) {
-    return path36.join(this.runRoot(run), INTEGRATION_DIR, repo.path);
+    return path37.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 (fs15.existsSync(path36.join(dir, ".git"))) return dir;
+      if (fs15.existsSync(path37.join(dir, ".git"))) return dir;
       await this.tryGit(repo.root, ["worktree", "prune"]);
       ensureStateDirIgnored(run.workspaceRoot);
-      fs15.mkdirSync(path36.dirname(dir), { recursive: true });
+      fs15.mkdirSync(path37.dirname(dir), { recursive: true });
       await this.git(repo.root, ["worktree", "add", "-q", dir, repo.integrationBranch]);
       return dir;
     });
@@ -25392,7 +25407,7 @@ var GitWorktreeIsolation = class {
     const removal = noRemoval();
     for (const repo of opts.preserve === false || record.readOnly ? [] : run.repos) {
       const entry = record.repos[repo.path];
-      const target = { worktree: entry?.worktree, linked: entry?.linked ?? [], branch: record.branch, name: path36.basename(record.workspace), title: record.title, commit: record.commit };
+      const target = { worktree: entry?.worktree, linked: entry?.linked ?? [], branch: record.branch, name: path37.basename(record.workspace), title: record.title, commit: record.commit };
       try {
         const kept = await this.preserve(run, repo, target, opts.intent);
         if (kept) removal.preserved.push({ task: task2, ...kept });
@@ -25473,7 +25488,7 @@ var GitWorktreeIsolation = class {
       return;
     }
     for (const entry of entries) {
-      const target = path36.join(dir, entry.name);
+      const target = path37.join(dir, entry.name);
       if (entry.isSymbolicLink()) this.unlinkIfLink(target);
       else if (entry.isDirectory()) this.unlinkLinksUnder(target);
     }
@@ -25495,20 +25510,20 @@ var GitWorktreeIsolation = class {
         return false;
       }
     };
-    const owned = new Set(Object.values(run.tasks).map((r) => path36.resolve(r.workspace)));
+    const owned = new Set(Object.values(run.tasks).map((r) => path37.resolve(r.workspace)));
     const root = this.runRoot(run);
     if (fs15.existsSync(root)) {
       for (const entry of fs15.readdirSync(root)) {
-        const dir = path36.join(root, entry);
-        if (entry === INTEGRATION_DIR || owned.has(path36.resolve(dir))) continue;
+        const dir = path37.join(root, entry);
+        if (entry === INTEGRATION_DIR || owned.has(path37.resolve(dir))) continue;
         let kept = true;
         for (const repo of run.repos) {
-          const worktree = path36.join(dir, repo.path);
-          const linked = leftoverLinks(path36.join(worktree, await this.prefixOf(repo)));
+          const worktree = path37.join(dir, repo.path);
+          const linked = leftoverLinks(path37.join(worktree, await this.prefixOf(repo)));
           if (!await keep2(repo, { worktree, linked, branch: null, name: entry, title: entry }, worktree)) kept = false;
         }
         if (!kept) continue;
-        for (const repo of run.repos) await this.removeWorktreeDir(run, repo, path36.join(dir, repo.path), []);
+        for (const repo of run.repos) await this.removeWorktreeDir(run, repo, path37.join(dir, repo.path), []);
         this.removeTaskWorkspace(run, dir);
       }
     }
@@ -25526,13 +25541,13 @@ var GitWorktreeIsolation = class {
   }
   async removeWorktreeDir(run, repo, dir, linked) {
     for (const name of /* @__PURE__ */ new Set([...linked, ...installDirs(dir)])) {
-      const target = path36.join(dir, name);
-      if (!resolvesAsNamed(this.runRoot(run), path36.dirname(target))) continue;
+      const target = path37.join(dir, name);
+      if (!resolvesAsNamed(this.runRoot(run), path37.dirname(target))) continue;
       this.unlinkIfLink(target);
       this.unlinkLinksUnder(target);
     }
     for (const name of resolvesAsNamed(this.runRoot(run), dir) ? fs15.readdirSync(dir) : []) {
-      if (LINKED_ARTIFACTS.has(name) || isEnvFile(name)) this.unlinkIfLink(path36.join(dir, name));
+      if (LINKED_ARTIFACTS.has(name) || isEnvFile(name)) this.unlinkIfLink(path37.join(dir, name));
     }
     await this.tryGit(repo.root, ["worktree", "remove", "--force", dir]);
     if (fs15.existsSync(dir) && isInside(this.runRoot(run), dir)) {
@@ -25540,7 +25555,7 @@ var GitWorktreeIsolation = class {
       fs15.rmSync(dir, { recursive: true, force: true });
     }
     await this.tryGit(repo.root, ["worktree", "prune"]);
-    for (let parent = path36.dirname(dir); isInside(this.runRoot(run), parent); parent = path36.dirname(parent)) this.removeIfEmpty(parent);
+    for (let parent = path37.dirname(dir); isInside(this.runRoot(run), parent); parent = path37.dirname(parent)) this.removeIfEmpty(parent);
   }
   unlinkIfLink(target) {
     try {
@@ -25555,14 +25570,14 @@ var GitWorktreeIsolation = class {
     }
   }
   runRoot(run) {
-    return path36.join(run.workspaceRoot, STATE_DIR, "worktrees", run.id);
+    return path37.join(run.workspaceRoot, STATE_DIR, "worktrees", run.id);
   }
   namesFor(run, task2) {
     const slug = sanitizeSlug(task2.title).slice(0, 40).replace(/-+$/, "") || "task";
     let name = `${task2.order}-${slug}`;
     const clash = Object.values(run.tasks).some((r) => r.taskId !== task2.id && r.branch === `ordewell/${run.id}/${name}`);
     if (clash) name = `${name}-${sanitizeSlug(task2.id) || "x"}`;
-    return { branch: `ordewell/${run.id}/${name}`, dir: path36.join(this.runRoot(run), name) };
+    return { branch: `ordewell/${run.id}/${name}`, dir: path37.join(this.runRoot(run), name) };
   }
   async unmergedPaths(cwd) {
     const listed3 = await this.tryGit(cwd, ["diff", "--name-only", "-z", "--diff-filter=U"]);
@@ -25576,7 +25591,7 @@ var GitWorktreeIsolation = class {
   async rebaseInProgress(cwd) {
     for (const dir of ["rebase-merge", "rebase-apply"]) {
       const found = await this.tryGit(cwd, ["rev-parse", "--git-path", dir]);
-      if (found.ok && fs15.existsSync(path36.resolve(cwd, found.stdout.trim()))) return true;
+      if (found.ok && fs15.existsSync(path37.resolve(cwd, found.stdout.trim()))) return true;
     }
     return false;
   }
@@ -25603,6 +25618,29 @@ function createWorktreeIsolation(deps) {
   return new GitWorktreeIsolation(deps);
 }
 
+// src/services/repositoryRunnerConfig.ts
+var RUNNER_CONFIG_ROOTS = [".mcp.json", ".claude", ".claude-plugin", "opencode.json", "opencode.jsonc", ".opencode", ".codex"];
+function repositoryRunnerConfigPaths(paths) {
+  return [...new Set(paths.filter(
+    (path49) => (
+      // Project MCP servers start commands or send data to a repository-chosen URL.
+      path49 === ".mcp.json" || // Settings can run hooks and helpers, load plugins, or redirect traffic.
+      path49 === ".claude/settings.json" || // Local settings have the same execution capabilities as project settings.
+      path49 === ".claude/settings.local.json" || // Hook files provide commands invoked by the runner.
+      path49.startsWith(".claude/hooks/") || // Plugin files can provide code and hooks loaded by the runner.
+      path49.startsWith(".claude/plugins/") || // Plugin metadata can load plugins and their executable components.
+      path49.startsWith(".claude-plugin/") || // Plugin and marketplace manifests can select code for the runner to load.
+      /^\.claude\/(?:[^/]+\/)*(?:plugin|marketplace)\.json$/.test(path49) || // OpenCode config declares MCP servers and plugins; its plugin and tool
+      // directories are code it loads, and an agent definition sets the prompt,
+      // model and permissions of the built-in agent its id names, which a task
+      // launches with. The rest of `.opencode/` is dependencies OpenCode
+      // installs itself, which a later launch must not be held for.
+      /^(?:\.opencode\/)?opencode\.jsonc?$/.test(path49) || /^\.opencode\/(?:plugins?|tools?|agents?)\//.test(path49) || // Codex project config carries MCP servers, hooks and `notify` commands.
+      path49.startsWith(".codex/")
+    )
+  ))].sort();
+}
+
 // src/interfaces/ILogger.ts
 var ConsoleLogger = class {
   warn(scope, message, err) {
@@ -28638,6 +28676,7 @@ var IsolationRunController = class {
   /** Resolver task id → the conflicted task it resolves; see {@link linkResolver}. */
   resolvers = {};
   opening = null;
+  opened = 0;
   /** Bumped by an interrupt, so an activation in flight across it does not open the run it ended. */
   activations = 0;
   /** The start a dirty tree turned away, handed back once the user chooses how to go on. */
@@ -28669,6 +28708,10 @@ var IsolationRunController = class {
   get isOpen() {
     return this.mode !== null;
   }
+  /** How many runs have opened: what tells one run's launches from the next one's. */
+  get epoch() {
+    return this.opened;
+  }
   /** The open run has decided whether it isolates. */
   get decided() {
     return this.mode === "isolated" || this.mode === "shared";
@@ -28766,6 +28809,7 @@ var IsolationRunController = class {
   open() {
     if (this.mode) return;
     this.mode = "undecided";
+    this.opened += 1;
   }
   /**
    * Decide once per run, as its first change task starts, whether it executes
@@ -29765,7 +29809,7 @@ function heldFrom(state) {
 }
 
 // src/services/Attempts.ts
-import * as path39 from "path";
+import * as path41 from "path";
 
 // src/services/VerdictEngine.ts
 var IDLE_TIMEOUT_MS = 10 * 6e4;
@@ -30153,10 +30197,132 @@ function reportedVerdict(report) {
   return { outcome: "fail", reason: `The runner reported the task ${report.status}: ${why}`, checks, decidedAt, reported };
 }
 
+// src/services/taskStartConfig.ts
+import * as path38 from "path";
+import { createHash as createHash4 } from "crypto";
+import { existsSync as existsSync15, lstatSync as lstatSync4, readdirSync as readdirSync8, readFileSync as readFileSync13, statSync as statSync12 } from "fs";
+var MAX_FILES = 2e3;
+var MAX_DEPTH = 8;
+function liveConfig(dir) {
+  const found = /* @__PURE__ */ new Map();
+  const visit = (rel, depth) => {
+    if (found.size >= MAX_FILES || depth > MAX_DEPTH) return;
+    const full = path38.join(dir, rel);
+    try {
+      const info = statSync12(full);
+      if (info.isFile()) {
+        found.set(rel, createHash4("sha1").update(readFileSync13(full)).digest("hex"));
+      } else if (info.isDirectory() && path38.basename(rel) !== "node_modules") {
+        for (const name of readdirSync8(full)) visit(path38.posix.join(rel, name), depth + 1);
+      }
+    } catch {
+    }
+  };
+  for (const root of RUNNER_CONFIG_ROOTS) visit(root, 0);
+  const selected = new Set(repositoryRunnerConfigPaths([...found.keys()]));
+  return new Map([...found].filter(([name]) => selected.has(name)));
+}
+function linkedRoots(dir) {
+  const linked = /* @__PURE__ */ new Set();
+  for (const root of RUNNER_CONFIG_ROOTS) {
+    try {
+      if (lstatSync4(path38.join(dir, root)).isSymbolicLink()) linked.add(root);
+    } catch {
+    }
+  }
+  return linked;
+}
+function readDirs(root) {
+  const dirs = [{ dir: root, prefix: "" }];
+  for (let dir = root, prefix = ""; !existsSync15(path38.join(dir, ".git")); ) {
+    const parent = path38.dirname(dir);
+    if (parent === dir) return [dirs[0]];
+    dir = parent;
+    prefix += "../";
+    dirs.push({ dir, prefix });
+  }
+  return dirs;
+}
+var TaskStartConfig = class {
+  live = /* @__PURE__ */ new Map();
+  /**
+   * `epoch` names the run the check belongs to; a new run takes a new
+   * baseline. `root` is the workspace root, the checkout a worktree run lands
+   * in; `cwd` is where the runner starts, and `worktree` whether that is a
+   * worktree prepared for it.
+   */
+  async check(run, taskId, where) {
+    const found = where.worktree ? await this.gitDifferences(run, taskId) : [];
+    const id2 = String(where.epoch);
+    const checkout = readDirs(where.root).flatMap(({ dir, prefix }) => this.liveDifferences(`${id2}:checkout:${dir}`, dir).map((name) => `${prefix}${name}`));
+    if (!where.worktree) found.push(...checkout);
+    else {
+      const cwd = where.cwd ?? run?.tasks[taskId]?.workspace;
+      if (cwd) found.push(...this.worktreeDifferences(id2, cwd, where.root));
+    }
+    return [...new Set(found)].sort();
+  }
+  /** The baselines go with the plan they belong to. */
+  clear() {
+    this.live.clear();
+  }
+  /**
+   * What a worktree's runner reads that differs from where the run started.
+   * The `.claude` and `.opencode` directories it links from the checkout are
+   * the checkout's own, so they are compared with the checkout's first state,
+   * which an earlier task's write there does not move. Anything else is the
+   * worktree's, and is compared with its own first state: a setup command's
+   * files are trusted, and a task's later write is not.
+   */
+  worktreeDifferences(id2, dir, root) {
+    const now = liveConfig(dir);
+    const linked = linkedRoots(dir);
+    const fromCheckout = (name) => linked.has(name.split("/")[0]);
+    const key = `${id2}:worktree:${dir}`;
+    let local = this.live.get(key);
+    if (!local) {
+      local = new Map([...now].filter(([name]) => !fromCheckout(name)));
+      this.live.set(key, local);
+    }
+    const checkout = this.live.get(`${id2}:checkout:${root}`);
+    return [...now].filter(([name, hash]) => fromCheckout(name) ? checkout?.get(name) !== hash : local.get(name) !== hash).map(([name]) => name);
+  }
+  liveDifferences(key, dir) {
+    const now = liveConfig(dir);
+    const before = this.live.get(key);
+    if (!before) {
+      this.live.set(key, now);
+      return [];
+    }
+    return [...now].filter(([name, hash]) => before.get(name) !== hash).map(([name]) => name);
+  }
+  async gitDifferences(run, taskId) {
+    if (!run) return [];
+    const invoker = { exec: defaultExecFile2, resolvePath: augmentedPath };
+    const found = [];
+    for (const repo of run.repos) {
+      const cwd = run.tasks[taskId]?.repos[repo.path]?.worktree;
+      if (!cwd || !repo.baseRef || !existsSync15(cwd)) continue;
+      const prefix = repo.path === "." ? (await tryGit(invoker, repo.root, ["rev-parse", "--show-prefix"])).stdout.trim() : "";
+      const roots = [...RUNNER_CONFIG_ROOTS, ...prefix ? RUNNER_CONFIG_ROOTS.map((r) => `${prefix}${r}`) : []];
+      const diff = await tryGit(invoker, cwd, ["diff", "--no-ext-diff", "--no-textconv", "--no-renames", "--name-only", "--diff-filter=ACMRTU", "-z", repo.baseRef, "--"]);
+      const untracked = await tryGit(invoker, cwd, ["ls-files", "--others", "-z", "--", ...roots]);
+      if (!diff.ok || !untracked.ok) continue;
+      for (const name of [...diff.stdout.split("\0"), ...untracked.stdout.split("\0")]) {
+        const here = prefix && name.startsWith(prefix) ? name.slice(prefix.length) : void 0;
+        if (repositoryRunnerConfigPaths([name]).length || here !== void 0 && repositoryRunnerConfigPaths([here]).length) {
+          found.push(repo.path === "." ? name : path38.posix.join(repo.path, name));
+        }
+      }
+    }
+    return found;
+  }
+};
+
 // src/services/ScriptRunner.ts
 import { spawn as nodeSpawn2 } from "child_process";
 import * as fs16 from "fs";
-import * as path37 from "path";
+import * as path39 from "path";
 import { EventEmitter as EventEmitter2 } from "events";
 import { StringDecoder as StringDecoder2 } from "string_decoder";
 
@@ -30297,7 +30463,7 @@ var ScriptSession = class extends AbstractRunnerSession {
   async launchOf(step) {
     if ("argv" in step) {
       const [named3, ...args] = step.argv;
-      const program = this.setup.platform === "win32" && path37.win32.basename(named3) !== named3 && !path37.win32.isAbsolute(named3) ? path37.win32.resolve(this.setup.cwd, named3) : named3;
+      const program = this.setup.platform === "win32" && path39.win32.basename(named3) !== named3 && !path39.win32.isAbsolute(named3) ? path39.win32.resolve(this.setup.cwd, named3) : named3;
       const plan = await planDirectLaunch(program, args, this.setup.launch);
       return { file: plan.file, args: plan.args, shell: false, ...plan.verbatim ? { verbatim: true } : {} };
     }
@@ -30530,10 +30696,10 @@ function passed(status) {
 }
 
 // src/services/PatchCapture.ts
-import { createHash as createHash4, randomBytes as randomBytes7 } from "crypto";
+import { createHash as createHash5, randomBytes as randomBytes7 } from "crypto";
 import * as fs17 from "fs";
 import * as os10 from "os";
-import * as path38 from "path";
+import * as path40 from "path";
 
 // src/services/readTask.ts
 function readTask2(args, readerId, plan, log) {
@@ -30800,7 +30966,7 @@ function linkInPatch(patch) {
 function readOwn(scratch, name, max) {
   let fd;
   try {
-    fd = fs17.openSync(path38.join(scratch, name), fs17.constants.O_RDONLY | (fs17.constants.O_NOFOLLOW ?? 0));
+    fd = fs17.openSync(path40.join(scratch, name), fs17.constants.O_RDONLY | (fs17.constants.O_NOFOLLOW ?? 0));
   } catch (err) {
     throw new Refusal(`the capture left no ${name.split(".").pop()} Ordewell could read (${err.code ?? String(err)})`);
   }
@@ -30838,7 +31004,7 @@ async function captureHeld(runs, opts, signal) {
   const [worktree] = runs.worktrees;
   const scratch = runs.scratch;
   const tag = `ordewell-patch-${randomBytes7(8).toString("hex")}`;
-  const stem = path38.join(scratch, tag);
+  const stem = path40.join(scratch, tag);
   const own = (suffix, max = LISTING_BYTES) => readOwn(scratch, `${tag}.${suffix}`, max);
   try {
     const stage = await runs.run(stageScript(stem, opts.linked ?? []), worktree);
@@ -30876,7 +31042,7 @@ async function captureHeld(runs, opts, signal) {
     return {
       kind: "saved",
       patch,
-      stats: { base, ...countedIn(patch), bytes: patch.length, sha256: createHash4("sha256").update(patch).digest("hex"), flags: [...flags, ...flag("normalized", normalized2)] }
+      stats: { base, ...countedIn(patch), bytes: patch.length, sha256: createHash5("sha256").update(patch).digest("hex"), flags: [...flags, ...flag("normalized", normalized2)] }
     };
   } catch (err) {
     if (err instanceof Refusal) return { kind: "refused", reason: `${err.message}.` };
@@ -30930,8 +31096,8 @@ async function indexEntries(invoker, worktree) {
   return entries;
 }
 async function trialApply(invoker, worktree, patchFile, scratch) {
-  const index = path38.resolve(worktree, (await git(invoker, worktree, [...APPLY_GIT, "rev-parse", "--git-path", "index"])).trim());
-  const copy = path38.join(scratch, "index");
+  const index = path40.resolve(worktree, (await git(invoker, worktree, [...APPLY_GIT, "rev-parse", "--git-path", "index"])).trim());
+  const copy = path40.join(scratch, "index");
   fs17.copyFileSync(index, copy);
   const trial = { ...invoker, exec: (file, args, opts) => invoker.exec(file, args, { ...opts, env: { ...opts.env, GIT_INDEX_FILE: copy } }) };
   const tried = await tryGit(trial, worktree, [...APPLY_GIT, "apply", "--cached", "--3way", "--whitespace=nowarn", patchFile]);
@@ -30951,7 +31117,7 @@ function gitRefused(lead, stderr) {
 function onDisk3(worktree, names) {
   return names.map((name) => {
     try {
-      const stat = fs17.lstatSync(path38.join(worktree, name), { bigint: true, throwIfNoEntry: false });
+      const stat = fs17.lstatSync(path40.join(worktree, name), { bigint: true, throwIfNoEntry: false });
       return stat ? `${stat.mode} ${stat.ino} ${stat.size} ${stat.mtimeNs} ${stat.ctimeNs}` : "none";
     } catch (err) {
       return err.code ?? "unreadable";
@@ -30991,7 +31157,7 @@ function leavesWorktree(worktree, names, linked, held2, left) {
       if (i < parts.length && held2.get(at)?.some((entry) => entry.mode === SUBMODULE)) {
         return `the patch writes ${name}, under ${at}, a submodule, whose files are another repository's.`;
       }
-      const full = path38.join(worktree, ...parts.slice(0, i));
+      const full = path40.join(worktree, ...parts.slice(0, i));
       const stat = fs17.lstatSync(full, { throwIfNoEntry: false });
       if (!stat) break;
       const last = i === parts.length;
@@ -31012,14 +31178,14 @@ async function applyPatch(invoker, worktree, patch, saved, opts = {}) {
   if (patch.length !== saved.bytes) {
     return refused3(`the patch is ${byteSize(patch.length)} where its artifact says ${byteSize(saved.bytes)}, so it was cut short or changed after it was saved.`);
   }
-  if (createHash4("sha256").update(patch).digest("hex") !== saved.sha256) {
+  if (createHash5("sha256").update(patch).digest("hex") !== saved.sha256) {
     return refused3("the patch is not the file that was saved: its hash is not the one its artifact records, so it was changed after it was saved.");
   }
   const link = linkInPatch(patch);
   if (link !== void 0) {
     return refused3(`the patch holds a link or a submodule (${JSON.stringify(link.slice(0, 80))}), which a saved patch never does, so it is not one that was saved.`);
   }
-  const dir = fs17.mkdtempSync(path38.join(os10.tmpdir(), "ordewell-apply-"));
+  const dir = fs17.mkdtempSync(path40.join(os10.tmpdir(), "ordewell-apply-"));
   try {
     const toplevel = (await git(invoker, worktree, [...APPLY_GIT, "rev-parse", "--show-toplevel"])).trim();
     if (fs17.realpathSync(toplevel) !== fs17.realpathSync(worktree)) return refused3(`${worktree} is not the root of a worktree of its own.`);
@@ -31029,7 +31195,7 @@ async function applyPatch(invoker, worktree, patch, saved, opts = {}) {
     }
     const before = await unmergedPaths(invoker, worktree);
     if (before.length > 0) return refused3(`your worktree still has unresolved conflicts (${listed(before.slice(0, 10))}${before.length > 10 ? `, +${before.length - 10} more` : ""}). Resolve them and git add them, or undo them, then apply the patch.`);
-    const file = path38.join(dir, "saved.patch");
+    const file = path40.join(dir, "saved.patch");
     fs17.writeFileSync(file, patch, { flag: "wx", mode: 384 });
     const held2 = await indexEntries(invoker, worktree);
     const named3 = await pathsNamed(invoker, worktree, file);
@@ -31179,6 +31345,11 @@ var TaskWebReader = class {
 };
 
 // src/services/Attempts.ts
+var TaskStartConfigError = class extends Error {
+  constructor(paths) {
+    super(`repository configuration ${paths.map((p) => JSON.stringify(p)).join(", ")} differs from where this run started; remove it to continue, or start a new run once your branch holds it`);
+  }
+};
 var DEFAULT_GIT = { exec: defaultExecFile2, resolvePath: () => augmentedPath() };
 var Attempts = class {
   constructor(deps) {
@@ -31210,6 +31381,7 @@ var Attempts = class {
   live = /* @__PURE__ */ new Map();
   /** Bumped by every plan load: an ended attempt's wind-down belongs to the scope before it. */
   planScope = 0;
+  startConfig = new TaskStartConfig();
   /** Each task's runners still winding down once stopped: a continue waits for them (ADR-0018, L1). */
   windDowns = /* @__PURE__ */ new Map();
   /**
@@ -31379,6 +31551,7 @@ var Attempts = class {
     const ended = this.endAll("load");
     this.planScope += 1;
     this.spawnCounts.clear();
+    this.startConfig.clear();
     return ended;
   }
   /** A task leaving the plan: no later attempt of it is numbered from its runs. */
@@ -31511,9 +31684,17 @@ var Attempts = class {
         if (unavailable2) throw new Error(unavailable2);
       }
       if (kind.kind === "continuation") await this.windDowns.get(task2.id);
+      if (!attempt.script && kind.kind === "repair") {
+        const paths = await this.startConfig.check(runs.current, task2.id, { epoch: runs.epoch, root: this.deps.workspaceRoot(), cwd: null, worktree: true });
+        if (paths.length) throw new TaskStartConfigError(paths);
+      }
       const { cwd, worktree, previousWork, workspace } = await attemptCwd(kind, task2, runs);
       attempt.cwd = cwd;
       attempt.worktree = worktree;
+      if (!attempt.script && kind.kind !== "repair" && !landsNothing(kind)) {
+        const paths = await this.startConfig.check(runs.current, task2.id, { epoch: runs.epoch, root: this.deps.workspaceRoot(), cwd, worktree });
+        if (paths.length) throw new TaskStartConfigError(paths);
+      }
       if (checksTree(kind)) attempt.snapshot = await runs.snapshotWorkspace();
       if (this.live.get(task2.id) !== attempt) {
         if (attempt.worktree && !this.live.has(task2.id) && !this.host.completing(task2.id)) await runs.release(task2.id, { keep: kind.kind === "repair" });
@@ -31596,6 +31777,9 @@ var Attempts = class {
       return { kind: "usage-limited", taskId: task2.id, attempt, said: { message }, output: "" };
     }
     const failed = (failure2) => ({ kind: "spawn-failed", task: task2, attempt, failure: failure2 });
+    if (err instanceof TaskStartConfigError) {
+      return failed({ leaves: "held", hold: err.message, preserveWorktree: true, settles: false, notice: { level: "warn", text: `Task "${task2.title}" is on hold: ${err.message}` } });
+    }
     if (attempt.kind.kind === "continuation" && !attachTimeout) {
       const refused3 = err instanceof RunnerStartupExit;
       const reason = unresumedMessage(task2, refused3 ? `${attempt.runner} could not find its saved session` : `could not start: ${message}`);
@@ -31732,9 +31916,9 @@ var Attempts = class {
     const repos = Object.values(this.deps.runs.openRecord(taskId)?.repos ?? {});
     if (repos.length !== 1 || cwd === null) return [];
     const [{ worktree, linked }] = repos;
-    const prefix = path39.relative(worktree, cwd).split(path39.sep).join("/");
-    if (prefix.startsWith("..") || path39.isAbsolute(prefix)) return [];
-    return linked.map((name) => (prefix ? `${prefix}/${name}` : name).split(path39.sep).join("/"));
+    const prefix = path41.relative(worktree, cwd).split(path41.sep).join("/");
+    if (prefix.startsWith("..") || path41.isAbsolute(prefix)) return [];
+    return linked.map((name) => (prefix ? `${prefix}/${name}` : name).split(path41.sep).join("/"));
   }
   /**
    * A script task's start (ADR-0035): its body as the plan holds it now, run
@@ -31772,7 +31956,7 @@ var Attempts = class {
       this.deps.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 ${path39.dirname(resolved.blockedEnvrc)} to use them.`);
+      warn(`blocked:${resolved.blockedEnvrc}`, `direnv has blocked ${resolved.blockedEnvrc}, so tasks start without its variables. Run \`direnv allow\` in ${path41.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.`);
@@ -31798,7 +31982,7 @@ var Attempts = class {
   uncommittedSkillFolder(name) {
     const root = this.deps.workspaceRoot();
     const skill = this.deps.skillsAt(this.skillRoots(root)).findSkill(name);
-    return skill?.source === "workspace" ? path39.relative(root, path39.dirname(skill.path)).split(path39.sep).join("/") : void 0;
+    return skill?.source === "workspace" ? path41.relative(root, path41.dirname(skill.path)).split(path41.sep).join("/") : void 0;
   }
   /**
    * The roots whose `.ordewell/skills/` an attempt at `cwd` reads: in a repo
@@ -32167,12 +32351,12 @@ function ancestors(task2, store) {
 
 // src/services/sessionLease.ts
 import * as fs19 from "fs";
-import * as path41 from "path";
+import * as path43 from "path";
 import { randomUUID as randomUUID6 } from "crypto";
 
 // src/utils/sessionStore.ts
 import * as fs18 from "fs";
-import * as path40 from "path";
+import * as path42 from "path";
 
 // src/utils/sessionId.ts
 import { randomBytes as randomBytes8 } from "crypto";
@@ -32183,13 +32367,13 @@ function mintSessionId() {
 // src/utils/sessionStore.ts
 var SESSIONS_SUBDIR = "sessions";
 function getSessionsDir(baseDir) {
-  return path40.join(getStateDir(baseDir), SESSIONS_SUBDIR);
+  return path42.join(getStateDir(baseDir), SESSIONS_SUBDIR);
 }
 function idSegment(id2) {
   return /^[A-Za-z0-9_-][A-Za-z0-9._-]{0,127}$/.test(id2) ? id2 : `~${Buffer.from(id2, "utf-8").toString("hex")}`;
 }
 function sessionDataDir(sessionId, baseDir) {
-  return path40.join(getSessionsDir(baseDir), idSegment(sessionId));
+  return path42.join(getSessionsDir(baseDir), idSegment(sessionId));
 }
 var REJECTION_MESSAGE = "This session was created with an older version of Ordewell. Please re-plan.";
 function isSessionMeta(value) {
@@ -32216,8 +32400,8 @@ function legacySessionFilename(session) {
   return `${filenameStem(session)}_${session.id.slice(0, 8)}.json`;
 }
 function dropLegacyFile(sessionsDir, meta) {
-  const legacy = path40.join(sessionsDir, legacySessionFilename(meta));
-  if (legacy === path40.join(sessionsDir, sessionFilename(meta)) || !fs18.existsSync(legacy)) return;
+  const legacy = path42.join(sessionsDir, legacySessionFilename(meta));
+  if (legacy === path42.join(sessionsDir, sessionFilename(meta)) || !fs18.existsSync(legacy)) return;
   try {
     const held2 = JSON.parse(fs18.readFileSync(legacy, "utf-8")).meta?.id;
     if (held2 === meta.id) fs18.unlinkSync(legacy);
@@ -32244,7 +32428,7 @@ function saveSession(plan, goal, baseDir, id2) {
   };
   dropRetiredPlanFields(session.plan);
   const filename = sessionFilename(meta);
-  const filePath = path40.join(sessionsDir, filename);
+  const filePath = path42.join(sessionsDir, filename);
   writeFileAtomic(filePath, JSON.stringify(session, null, 2));
   dropLegacyFile(sessionsDir, meta);
   return meta;
@@ -32256,7 +32440,7 @@ function listSessions(baseDir, logger = defaultLogger) {
   return files.map((f) => {
     let parsed;
     try {
-      parsed = JSON.parse(fs18.readFileSync(path40.join(sessionsDir, f), "utf-8"));
+      parsed = JSON.parse(fs18.readFileSync(path42.join(sessionsDir, f), "utf-8"));
     } catch (err) {
       if (err instanceof SyntaxError) return moveAside(sessionsDir, f, "is not valid JSON", logger);
       logger.warn("sessionStore", `failed to read session file ${f}; skipping`, err);
@@ -32277,7 +32461,7 @@ function listSessions(baseDir, logger = defaultLogger) {
 function moveAside(sessionsDir, file, reason, logger) {
   const aside = `${file}.${Date.now()}.corrupt`;
   try {
-    fs18.renameSync(path40.join(sessionsDir, file), path40.join(sessionsDir, aside));
+    fs18.renameSync(path42.join(sessionsDir, file), path42.join(sessionsDir, aside));
     logger.warn("sessionStore", `session file ${file} ${reason}; moved aside to ${aside} rather than overwritten`);
   } catch {
     logger.warn("sessionStore", `failed to read session file ${file}; skipping`);
@@ -32288,7 +32472,7 @@ function findSessionFile(sessionsDir, sessionId, logger) {
   const files = fs18.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
   for (const f of files) {
     try {
-      const raw = fs18.readFileSync(path40.join(sessionsDir, f), "utf-8");
+      const raw = fs18.readFileSync(path42.join(sessionsDir, f), "utf-8");
       const session = JSON.parse(raw);
       if (session.meta.id === sessionId) return f;
     } catch (err) {
@@ -32303,7 +32487,7 @@ function loadSession(sessionId, baseDir, logger = defaultLogger) {
   try {
     const file = findSessionFile(sessionsDir, sessionId, logger);
     if (file) {
-      const raw = fs18.readFileSync(path40.join(sessionsDir, file), "utf-8");
+      const raw = fs18.readFileSync(path42.join(sessionsDir, file), "utf-8");
       const parsed = JSON.parse(raw);
       if (hasScalarRunner(parsed)) {
         logger.warn("sessionStore", `session file ${file}: ${REJECTION_MESSAGE}`);
@@ -32345,7 +32529,7 @@ function deleteSession(sessionId, baseDir, logger = defaultLogger) {
   try {
     const file = findSessionFile(sessionsDir, sessionId, logger);
     if (file) {
-      fs18.unlinkSync(path40.join(sessionsDir, file));
+      fs18.unlinkSync(path42.join(sessionsDir, file));
       return true;
     }
   } catch (err) {
@@ -32398,7 +32582,7 @@ var UNLEASED = {
 };
 var hostsHere = /* @__PURE__ */ new Set();
 function leaseFile(sessionId, workspace) {
-  return path41.join(sessionDataDir(sessionId, workspace), LEASE_FILE);
+  return path43.join(sessionDataDir(sessionId, workspace), LEASE_FILE);
 }
 function isRecord6(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -32487,7 +32671,7 @@ var LeaseHost = class {
    */
   acquire(file, workspace, holder) {
     ensureStateDirIgnored(workspace);
-    ensurePrivateDir(path41.dirname(file));
+    ensurePrivateDir(path43.dirname(file));
     const outcome = withFileLock(file, () => {
       const current = readRecord(file);
       const taken = current !== null && current.hostId !== this.id ? current : null;
@@ -32542,7 +32726,7 @@ var LeaseHost = class {
       withFileLock(file, () => {
         if (readRecord(file)?.hostId === this.id) fs19.rmSync(file, { force: true });
       }, "release a session lease");
-      fs19.rmdirSync(path41.dirname(file));
+      fs19.rmdirSync(path43.dirname(file));
     } catch {
     }
   }
@@ -33488,7 +33672,9 @@ var TaskOrchestrator = class _TaskOrchestrator {
         this.store.markPending(task2.id);
         this.hold(task2.id, failure2.hold, false);
       }
-      await this.runs.release(task2.id, { keep: failure2.leaves === "failed" && failure2.keepWorktree });
+      if (failure2.leaves !== "held" || !failure2.preserveWorktree) {
+        await this.runs.release(task2.id, { keep: failure2.leaves === "failed" && failure2.keepWorktree });
+      }
       const { level, text: text4, toastOnly } = failure2.notice;
       if (toastOnly) this.notifications[level](text4);
       else this.tell(level, text4);
@@ -35304,7 +35490,7 @@ import { spawn as nodeSpawn3 } from "child_process";
 import { randomUUID as randomUUID7 } from "crypto";
 import { mkdtempSync as mkdtempSync5, rmSync as rmSync12 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join37 } from "path";
+import { join as join39 } from "path";
 var DEFAULT_TIMEOUT_MS5 = 2e4;
 var INITIALIZE_TIMEOUT_MS2 = 1e4;
 var USAGE_TIMEOUT_MS = 1e4;
@@ -35336,7 +35522,7 @@ function claudeAccountLimitCollector(options) {
   };
 }
 async function readClaudeAccountLimits(options, signal) {
-  const cwd = mkdtempSync5(join37(tmpdir6(), "ordewell-claude-limits-"));
+  const cwd = mkdtempSync5(join39(tmpdir6(), "ordewell-claude-limits-"));
   const removeCwd = () => {
     try {
       rmSync12(cwd, { recursive: true, force: true });
@@ -35423,10 +35609,10 @@ function isoInstant(value) {
 import { homedir as homedir9 } from "os";
 
 // src/services/harness/openCodeCredentials.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { promises as fs20 } from "fs";
 import { homedir as osHomedir } from "os";
-import { join as join38, resolve as resolve13 } from "path";
+import { join as join40, resolve as resolve13 } from "path";
 import { Worker } from "worker_threads";
 var DEFAULT_TIMEOUT_MS6 = 5e3;
 var BUSY_MS = 250;
@@ -35481,11 +35667,11 @@ function walStore(path) {
 parentPort.postMessage(select());
 `;
 var isRecord9 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var digest = (...parts) => createHash5("sha256").update(parts.join("\0")).digest("hex").slice(0, 32);
+var digest = (...parts) => createHash6("sha256").update(parts.join("\0")).digest("hex").slice(0, 32);
 function openCodeStorePaths(env, home) {
-  const data = join38(env.XDG_DATA_HOME || join38(home, ".local", "share"), "opencode");
+  const data = join40(env.XDG_DATA_HOME || join40(home, ".local", "share"), "opencode");
   const file = env.OPENCODE_DB || "opencode.db";
-  return { db: file === ":memory:" ? null : resolve13(data, file), auth: join38(data, "auth.json") };
+  return { db: file === ":memory:" ? null : resolve13(data, file), auth: join40(data, "auth.json") };
 }
 function openCodeGoLoginReader(deps = {}) {
   const homedir10 = deps.homedir ?? osHomedir;
@@ -35547,8 +35733,8 @@ function v2Login(db, row) {
     login: { route: "console", owner: digest("console", db, row.id, account, orgID ?? ""), access: value.access, ...orgID ? { orgID } : {}, expires: value.expires }
   };
 }
-async function legacyLogin(path47, env) {
-  const content = env.OPENCODE_AUTH_CONTENT ?? await readSmall(path47);
+async function legacyLogin(path49, env) {
+  const content = env.OPENCODE_AUTH_CONTENT ?? await readSmall(path49);
   if (content === void 0) return env[ENV_KEY] ? { kind: "unsupported" } : { kind: "none" };
   if (content === null) return { kind: "unreadable" };
   const auth = parseJson(content);
@@ -35557,15 +35743,15 @@ async function legacyLogin(path47, env) {
   if (entry === void 0) return env[ENV_KEY] ? { kind: "unsupported" } : { kind: "none" };
   if (!isRecord9(entry) || entry.type !== "api") return { kind: "unsupported" };
   if (typeof entry.key !== "string" || entry.key.length === 0) return { kind: "unreadable" };
-  return { kind: "login", login: { route: "key", owner: digest("v1", path47, entry.key), key: entry.key } };
+  return { kind: "login", login: { route: "key", owner: digest("v1", path49, entry.key), key: entry.key } };
 }
-function queryStore(path47, signal, deps) {
+function queryStore(path49, signal, deps) {
   return new Promise((settle) => {
     let worker;
     try {
       worker = (deps.spawnWorker ?? ((source, options) => new Worker(source, options)))(WORKER_SOURCE, {
         eval: true,
-        workerData: { path: path47, integrations: GO_INTEGRATIONS, busyMs: BUSY_MS, maxValueBytes: MAX_VALUE_BYTES },
+        workerData: { path: path49, integrations: GO_INTEGRATIONS, busyMs: BUSY_MS, maxValueBytes: MAX_VALUE_BYTES },
         execArgv: deps.workerExecArgv ?? [],
         resourceLimits: { maxOldGenerationSizeMb: 64 }
       });
@@ -35592,19 +35778,19 @@ function queryStore(path47, signal, deps) {
     worker.once("exit", aborted);
   });
 }
-async function stamp(path47) {
+async function stamp(path49) {
   try {
-    const stat = await fs20.stat(path47);
+    const stat = await fs20.stat(path49);
     return [stat.ino, stat.size, stat.mtimeMs];
   } catch {
     return null;
   }
 }
-async function readSmall(path47) {
+async function readSmall(path49) {
   try {
-    const stat = await fs20.stat(path47);
+    const stat = await fs20.stat(path49);
     if (!stat.isFile() || stat.size > MAX_AUTH_FILE_BYTES) return null;
-    return await fs20.readFile(path47, "utf8");
+    return await fs20.readFile(path49, "utf8");
   } catch (err) {
     return err.code === "ENOENT" ? void 0 : null;
   }
@@ -36733,20 +36919,20 @@ function createAiService(config, deps) {
 }
 
 // src/services/createSession.ts
-import * as path44 from "path";
+import * as path46 from "path";
 
 // src/services/handoffReferences.ts
 import * as fs21 from "fs";
-import * as path42 from "path";
+import * as path44 from "path";
 import { spawnSync as spawnSync2 } from "child_process";
 function resolveHandoffReferences(handoff, workspace) {
   const checked = /* @__PURE__ */ new Map();
   const contained = (candidate) => {
     try {
       const root = fs21.realpathSync(workspace);
-      const resolved = fs21.realpathSync(path42.resolve(root, candidate));
-      const relative17 = path42.relative(root, resolved);
-      return relative17 !== ".." && !relative17.startsWith(`..${path42.sep}`) && !path42.isAbsolute(relative17) ? resolved : void 0;
+      const resolved = fs21.realpathSync(path44.resolve(root, candidate));
+      const relative17 = path44.relative(root, resolved);
+      return relative17 !== ".." && !relative17.startsWith(`..${path44.sep}`) && !path44.isAbsolute(relative17) ? resolved : void 0;
     } catch {
       return void 0;
     }
@@ -36767,7 +36953,7 @@ function resolveHandoffReferences(handoff, workspace) {
       }
     } else if (/^[0-9a-fA-F]{4,64}$/.test(ref.sha)) {
       const repo = contained(ref.repo ?? ".");
-      if (repo && fs21.existsSync(path42.join(repo, ".git"))) {
+      if (repo && fs21.existsSync(path44.join(repo, ".git"))) {
         const result2 = spawnSync2("git", ["--no-optional-locks", "--no-replace-objects", "cat-file", "-t", ref.sha], {
           cwd: repo,
           encoding: "utf8",
@@ -38242,10 +38428,10 @@ var SessionEventRelay = class {
 
 // src/utils/taskLogStore.ts
 import * as fs22 from "fs";
-import * as path43 from "path";
+import * as path45 from "path";
 var EXTENSION = ".jsonl";
 function taskDir({ baseDir, sessionId }, taskId) {
-  return path43.join(sessionDataDir(sessionId, baseDir), "tasks", idSegment(taskId));
+  return path45.join(sessionDataDir(sessionId, baseDir), "tasks", idSegment(taskId));
 }
 function listTaskLogAttempts(location, taskId) {
   let names;
@@ -38263,7 +38449,7 @@ function openTaskLog(location, taskId, attempt) {
   const next = (listTaskLogAttempts(location, taskId).pop() ?? 0) + 1;
   let number = attempt !== void 0 && Number.isInteger(attempt) && attempt >= 1 ? attempt : next;
   for (; ; ) {
-    const file = path43.join(dir, `${number}${EXTENSION}`);
+    const file = path45.join(dir, `${number}${EXTENSION}`);
     try {
       fs22.writeFileSync(file, "", { flag: "wx" });
     } catch (err) {
@@ -38287,15 +38473,15 @@ function prepareTaskOutputFile(location, taskId, attempt) {
   ensureStateDirIgnored(location.baseDir);
   const dir = taskDir(location, taskId);
   fs22.mkdirSync(dir, { recursive: true });
-  return path43.join(dir, `${attempt}.output.txt`);
+  return path45.join(dir, `${attempt}.output.txt`);
 }
 function taskPatchFile(location, taskId, attempt) {
-  return path43.join(taskDir(location, taskId), `${attempt}.patch`);
+  return path45.join(taskDir(location, taskId), `${attempt}.patch`);
 }
 function saveTaskPatch(location, taskId, attempt, patch) {
   ensureStateDirIgnored(location.baseDir);
   const file = taskPatchFile(location, taskId, attempt);
-  fs22.mkdirSync(path43.dirname(file), { recursive: true });
+  fs22.mkdirSync(path45.dirname(file), { recursive: true });
   const partial = `${file}.${process.pid}-${Date.now()}.partial`;
   fs22.writeFileSync(partial, patch, { flag: "wx" });
   fs22.renameSync(partial, file);
@@ -38316,7 +38502,7 @@ function readTaskLog(location, taskId, attempt) {
   if (!Number.isInteger(attempt) || attempt < 1) return [];
   let raw;
   try {
-    raw = fs22.readFileSync(path43.join(taskDir(location, taskId), `${attempt}${EXTENSION}`), "utf-8");
+    raw = fs22.readFileSync(path45.join(taskDir(location, taskId), `${attempt}${EXTENSION}`), "utf-8");
   } catch {
     return [];
   }
@@ -40345,7 +40531,7 @@ function createSession(deps) {
     ...deps.openTaskLog ? {} : {
       keepPatch: (taskId, attempt, patch) => {
         const location = session.taskLogLocation;
-        return path44.relative(location.baseDir, saveTaskPatch(location, taskId, attempt, patch)).split(path44.sep).join("/");
+        return path46.relative(location.baseDir, saveTaskPatch(location, taskId, attempt, patch)).split(path46.sep).join("/");
       }
     },
     recordHandoff: (sessionId, taskId, handoff) => taskLogs.note(sessionId, taskId, { type: "handoff", handoff }),
@@ -43186,7 +43372,7 @@ var RunnerRegistry = class {
 
 // src/plugins/removedPluginNotice.ts
 import * as fs23 from "fs";
-import * as path45 from "path";
+import * as path47 from "path";
 function isManifestFile(file) {
   try {
     return fs23.statSync(file).isFile();
@@ -43195,10 +43381,10 @@ function isManifestFile(file) {
   }
 }
 function removedPluginNotice(dataDir = globalDataDir()) {
-  const directory = path45.join(dataDir, "plugins");
+  const directory = path47.join(dataDir, "plugins");
   try {
-    const hasManifest = isManifestFile(path45.join(directory, "manifest.json")) || fs23.readdirSync(directory, { withFileTypes: true }).some(
-      (entry) => (entry.isDirectory() || entry.isSymbolicLink()) && isManifestFile(path45.join(directory, entry.name, "manifest.json"))
+    const hasManifest = isManifestFile(path47.join(directory, "manifest.json")) || fs23.readdirSync(directory, { withFileTypes: true }).some(
+      (entry) => (entry.isDirectory() || entry.isSymbolicLink()) && isManifestFile(path47.join(directory, entry.name, "manifest.json"))
     );
     if (hasManifest) return "Plugin runners were removed; manifests in ~/.ordewell/plugins/ are ignored. See the CHANGELOG.";
   } catch {
@@ -43209,15 +43395,15 @@ function removedPluginNotice(dataDir = globalDataDir()) {
 
 // src/utils/stateStore.ts
 import * as fs24 from "fs";
-import * as path46 from "path";
+import * as path48 from "path";
 var STATE_FILE2 = "state.json";
 function getStatePath(baseDir) {
-  return path46.join(getStateDir(baseDir), STATE_FILE2);
+  return path48.join(getStateDir(baseDir), STATE_FILE2);
 }
 var SESSION_ID_KEY = "sessionId";
 function saveState(plan, baseDir, sessionId) {
   const statePath = getStatePath(baseDir ?? process.cwd());
-  ensureDir(path46.dirname(statePath));
+  ensureDir(path48.dirname(statePath));
   plan.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
   const file = sessionId ? { ...plan, [SESSION_ID_KEY]: sessionId } : plan;
   dropRetiredPlanFields(file);
@@ -43765,6 +43951,7 @@ export {
   repoBaseLine,
   repoResultLines,
   reposWithWork,
+  repositoryRunnerConfigPaths,
   researchShellWarning,
   researchToolsPath,
   resetInstalledPlanner,