@dmrlzz/davecode 0.5.3 → 0.6.0

package/dist/{chunk-ING5HCIO.js → chunk-2XGDILCW.js}

@@ -123,6 +123,18 @@ import { z as z10 } from "zod";
 import { readdir as readdir3 } from "fs/promises";
 import { join as join7, relative as relative2 } from "path";
 import { z as z11 } from "zod";
+import { z as z12 } from "zod";
+import { existsSync as existsSync4, mkdtempSync, realpathSync, rmSync as rmSync4, statSync as statSync3 } from "fs";
+import { tmpdir } from "os";
+import path8 from "path";
+import { randomBytes as randomBytes9 } from "crypto";
+import { z as z13 } from "zod";
+import { createHash as createHash3 } from "crypto";
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join8, resolve as resolve5 } from "path";
+import { z as z14 } from "zod";
+import { existsSync as existsSync5, realpathSync as realpathSync2, rmSync as rmSync5 } from "fs";
+import path9 from "path";
 var credentials = z.object({ clientId: z.string().min(1), clientSecret: z.string().min(1) });
 var optionsSchema = z.object({
   origin: z.string().url().refine((value) => {
@@ -343,10 +355,10 @@ var H2 = /^##[ \t]+(\S.*?)[ \t]*$/;
 function stripCr(line) {
   return line.endsWith("\r") ? line.slice(0, -1) : line;
 }
-function listSections(lines) {
+function listSections(lines2) {
   const sections = [];
   let fence;
-  lines.forEach((raw, index) => {
+  lines2.forEach((raw, index) => {
     const line = stripCr(raw);
     const fenceMatch = FENCE.exec(line);
     if (fenceMatch) {
@@ -363,7 +375,7 @@ function listSections(lines) {
       sections.push({
         heading: match[1].replace(/\s+#+$/, ""),
         start: index,
-        end: lines.length
+        end: lines2.length
       });
     }
   });
@@ -371,17 +383,17 @@ function listSections(lines) {
 }
 var sameHeading = (a, b) => a.trim().toLowerCase() === b.trim().toLowerCase();
 function getSection(markdown, heading2) {
-  const lines = markdown.split("\n");
-  const section = listSections(lines).find((s) => sameHeading(s.heading, heading2));
+  const lines2 = markdown.split("\n");
+  const section = listSections(lines2).find((s) => sameHeading(s.heading, heading2));
   if (!section) return void 0;
-  return lines.slice(section.start + 1, section.end).map(stripCr).join("\n").trim();
+  return lines2.slice(section.start + 1, section.end).map(stripCr).join("\n").trim();
 }
 function upsertSection(markdown, heading2, body) {
   const crlf = markdown.includes("\r\n");
   const cr = crlf ? "\r" : "";
   const block = [`## ${heading2.trim()}`, "", ...body.trim().split(/\r?\n/)].map((l) => l + cr);
-  const lines = markdown.split("\n");
-  const section = listSections(lines).find((s) => sameHeading(s.heading, heading2));
+  const lines2 = markdown.split("\n");
+  const section = listSections(lines2).find((s) => sameHeading(s.heading, heading2));
   if (!section) {
     const base = markdown.replace(/\s+$/, "");
     if (base === "") return `${block.join("\n")}
@@ -389,9 +401,9 @@ function upsertSection(markdown, heading2, body) {
     return `${base}${crlf ? "\r\n\r\n" : "\n\n"}${block.join("\n")}
 `;
   }
-  const after = lines.slice(section.end);
+  const after = lines2.slice(section.end);
   const replacement = after.length > 0 ? [...block, cr] : [...block, ""];
-  return [...lines.slice(0, section.start), ...replacement, ...after].join("\n");
+  return [...lines2.slice(0, section.start), ...replacement, ...after].join("\n");
 }
 var LAST_UPDATED = /^_Last updated: \d{4}-\d{2}-\d{2}_[ \t]*(\r?)$/m;
 function touchLastUpdated(markdown, date) {
@@ -472,28 +484,28 @@ var LOG_MARKER = "_[\u2026 older entries truncated to fit the context budget]_";
 var heading = (title) => `===== ${title} =====`;
 var EMPTY = "(empty)";
 function describeTask(task, graph) {
-  const lines = [`id: ${task.id}`, `title: ${task.title}`, `status: ${task.status}`];
-  if (task.attempts) lines.push(`attempts so far: ${task.attempts}`);
-  if (task.branch) lines.push(`branch: ${task.branch}`);
-  if (task.description) lines.push("", "Description:", task.description.trim());
+  const lines2 = [`id: ${task.id}`, `title: ${task.title}`, `status: ${task.status}`];
+  if (task.attempts) lines2.push(`attempts so far: ${task.attempts}`);
+  if (task.branch) lines2.push(`branch: ${task.branch}`);
+  if (task.description) lines2.push("", "Description:", task.description.trim());
   if (task.acceptance?.length) {
-    lines.push("", "Acceptance criteria:", ...task.acceptance.map((c) => `- ${c}`));
+    lines2.push("", "Acceptance criteria:", ...task.acceptance.map((c) => `- ${c}`));
   }
-  if (task.notes) lines.push("", "Notes from previous attempts:", task.notes.trim());
+  if (task.notes) lines2.push("", "Notes from previous attempts:", task.notes.trim());
   if (task.dependsOn.length > 0) {
-    lines.push("", "Dependencies:");
+    lines2.push("", "Dependencies:");
     const byId = new Map(graph?.tasks.map((t) => [t.id, t]));
     for (const id of task.dependsOn) {
       const dep = byId.get(id);
       if (!dep) {
-        lines.push(`- ${id}: (not found in the task graph)`);
+        lines2.push(`- ${id}: (not found in the task graph)`);
         continue;
       }
       const note = dep.notes?.trim().split("\n")[0]?.slice(0, 200);
-      lines.push(`- ${dep.id}: ${dep.title} [${dep.status}]${note ? ` (${note})` : ""}`);
+      lines2.push(`- ${dep.id}: ${dep.title} [${dep.status}]${note ? ` (${note})` : ""}`);
     }
   }
-  return lines.join("\n");
+  return lines2.join("\n");
 }
 function cutEnd(text, excess, omittedLabel = OMITTED_MARKER) {
   const keep = text.length - excess - CONTEXT_TRUNCATION_MARKER.length - 1;
@@ -504,15 +516,15 @@ ${CONTEXT_TRUNCATION_MARKER}`;
 function trimActivityLog(state, excess) {
   const body = getSection(state, "Activity log");
   if (body === void 0) return state;
-  const lines = body.split("\n").filter((l) => l !== LOG_MARKER);
+  const lines2 = body.split("\n").filter((l) => l !== LOG_MARKER);
   let removed = 0;
   let drop = 0;
   const needed = excess + LOG_MARKER.length + 1;
-  while (drop < lines.length && removed < needed) {
-    removed += lines[drop].length + 1;
+  while (drop < lines2.length && removed < needed) {
+    removed += lines2[drop].length + 1;
     drop++;
   }
-  const kept = lines.slice(drop);
+  const kept = lines2.slice(drop);
   return upsertSection(state, "Activity log", [LOG_MARKER, ...kept].join("\n"));
 }
 async function buildTaskContext(input) {
@@ -573,16 +585,16 @@ function projectPaths(root) {
     taskGraph: join(dir, "TASK_GRAPH.json")
   };
 }
-var sleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
+var sleep = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
 var RETRYABLE_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]);
-async function atomicWriteFile(path8, content) {
-  await mkdir(dirname(path8), { recursive: true });
-  const tmp = `${path8}.${process.pid}.${randomBytes2(4).toString("hex")}.tmp`;
+async function atomicWriteFile(path10, content) {
+  await mkdir(dirname(path10), { recursive: true });
+  const tmp = `${path10}.${process.pid}.${randomBytes2(4).toString("hex")}.tmp`;
   try {
     await writeFile(tmp, content, "utf8");
     for (let attempt = 0; ; attempt++) {
       try {
-        await rename(tmp, path8);
+        await rename(tmp, path10);
         return;
       } catch (err) {
         const code = err.code;
@@ -595,9 +607,9 @@ async function atomicWriteFile(path8, content) {
     throw err;
   }
 }
-async function readFileIfExists(path8) {
+async function readFileIfExists(path10) {
   try {
-    return await readFile(path8, "utf8");
+    return await readFile(path10, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return void 0;
     throw err;
@@ -1028,10 +1040,10 @@ var LockTimeoutError = class extends Error {
   lockPath;
 };
 var TRANSIENT_OPEN_ERRORS = ["EPERM", "EACCES", "EBUSY"];
-var sleep2 = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
-async function readLockInfo(path8) {
+var sleep2 = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
+async function readLockInfo(path10) {
   try {
-    const parsed = JSON.parse(await readFile2(path8, "utf8"));
+    const parsed = JSON.parse(await readFile2(path10, "utf8"));
     if (typeof parsed === "object" && parsed !== null && typeof parsed.ts === "number" && typeof parsed.pid === "number") {
       return parsed;
     }
@@ -1039,11 +1051,11 @@ async function readLockInfo(path8) {
   }
   return void 0;
 }
-async function lockAge(path8) {
-  const info = await readLockInfo(path8);
+async function lockAge(path10) {
+  const info = await readLockInfo(path10);
   if (info) return Date.now() - info.ts;
   try {
-    return Date.now() - (await stat2(path8)).mtimeMs;
+    return Date.now() - (await stat2(path10)).mtimeMs;
   } catch {
     return void 0;
   }
@@ -1090,9 +1102,9 @@ async function withFileLock(lockPath, fn2, opts = {}) {
     }
   }
 }
-async function exists(path8) {
+async function exists(path10) {
   try {
-    await access(path8);
+    await access(path10);
     return true;
   } catch {
     return false;
@@ -1151,8 +1163,8 @@ var MissingBrainError = class extends Error {
   /** HTTP status hint and machine-readable code for the gateway's error handler. */
   statusCode = 409;
   code = "no_brain";
-  constructor(path8) {
-    super(`Missing project brain file: ${path8} (run ProjectBrain.init first)`);
+  constructor(path10) {
+    super(`Missing project brain file: ${path10} (run ProjectBrain.init first)`);
     this.name = "MissingBrainError";
   }
 };
@@ -1190,8 +1202,8 @@ var ProjectBrain = class _ProjectBrain {
       [brain.paths.architecture, architectureTemplate(name)],
       [brain.paths.taskGraph, serializeGraph(taskGraphTemplate())]
     ];
-    for (const [path8, content] of files) {
-      if (!await exists(path8)) await atomicWriteFile(path8, content);
+    for (const [path10, content] of files) {
+      if (!await exists(path10)) await atomicWriteFile(path10, content);
     }
     return brain;
   }
@@ -1303,10 +1315,10 @@ ${line}` : line);
     this.events?.emit({ type: "task.updated", task });
     return task;
   }
-  async readText(path8) {
-    const content = await readFileIfExists(path8);
+  async readText(path10) {
+    const content = await readFileIfExists(path10);
     if (content === void 0) {
-      throw new MissingBrainError(path8);
+      throw new MissingBrainError(path10);
     }
     return content;
   }
@@ -1520,14 +1532,14 @@ function filterProjectLayer(layer) {
     const out = {};
     for (const [key, v] of Object.entries(value)) {
       const rule = Object.hasOwn(tree, key) ? tree[key] : void 0;
-      const path8 = prefix ? `${prefix}.${key}` : key;
+      const path10 = prefix ? `${prefix}.${key}` : key;
       if (rule === true) {
         out[key] = v;
       } else if (rule && isPlainObject(v)) {
-        const inner = walk(v, rule, path8);
+        const inner = walk(v, rule, path10);
         if (Object.keys(inner).length > 0) out[key] = inner;
       } else {
-        dropped.push(path8);
+        dropped.push(path10);
       }
     }
     return out;
@@ -1552,21 +1564,21 @@ function deepMerge(base, override) {
   }
   return out;
 }
-function readLayer(path8, project) {
+function readLayer(path10, project) {
   let raw;
   try {
-    raw = readFileSync(path8, "utf8");
+    raw = readFileSync(path10, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return void 0;
-    throw new ConfigError(path8, `cannot read file: ${err.message}`, { cause: err });
+    throw new ConfigError(path10, `cannot read file: ${err.message}`, { cause: err });
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
-    throw new ConfigError(path8, `malformed JSON: ${err.message}`, { cause: err });
+    throw new ConfigError(path10, `malformed JSON: ${err.message}`, { cause: err });
   }
-  if (!isPlainObject(parsed)) throw new ConfigError(path8, "expected a JSON object");
+  if (!isPlainObject(parsed)) throw new ConfigError(path10, "expected a JSON object");
   let layer = parsed;
   if (project) {
     const { allowed, dropped } = filterProjectLayer(parsed);
@@ -1574,7 +1586,7 @@ function readLayer(path8, project) {
     layer = allowed;
   }
   const result = configSchema.safeParse(layer);
-  if (!result.success) throw new ConfigError(path8, z4.prettifyError(result.error));
+  if (!result.success) throw new ConfigError(path10, z4.prettifyError(result.error));
   return layer;
 }
 var TRUE_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
@@ -1653,19 +1665,19 @@ function loadConfig(options = {}) {
 }
 var isPlainObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 async function writeGlobalRouting(home, update, lock = {}) {
-  const path8 = globalPaths(home).config;
+  const path10 = globalPaths(home).config;
   return withFileLock(
-    `${path8}.lock`,
+    `${path10}.lock`,
     async () => {
       let current = {};
       try {
-        const parsed = JSON.parse(await readFile3(path8, "utf8"));
-        if (!isPlainObject2(parsed)) throw new ConfigError(path8, "expected a JSON object");
+        const parsed = JSON.parse(await readFile3(path10, "utf8"));
+        if (!isPlainObject2(parsed)) throw new ConfigError(path10, "expected a JSON object");
         current = parsed;
       } catch (err) {
         if (err instanceof ConfigError) throw err;
         if (!isNodeError(err, "ENOENT")) {
-          throw new ConfigError(path8, `cannot update this file: ${err.message}`, {
+          throw new ConfigError(path10, `cannot update this file: ${err.message}`, {
             cause: err
           });
         }
@@ -1680,11 +1692,11 @@ async function writeGlobalRouting(home, update, lock = {}) {
         }
       };
       const checked = configSchema.safeParse(next);
-      if (!checked.success) throw new ConfigError(path8, z5.prettifyError(checked.error));
-      await atomicWriteFile(path8, `${JSON.stringify(next, null, 2)}
+      if (!checked.success) throw new ConfigError(path10, z5.prettifyError(checked.error));
+      await atomicWriteFile(path10, `${JSON.stringify(next, null, 2)}
 `);
       return {
-        path: path8,
+        path: path10,
         routes: checked.data.routing.routes,
         defaultRoute: checked.data.routing.defaultRoute
       };
@@ -1772,8 +1784,8 @@ function makeUsage(prompt, completion) {
 function stripProviderPrefix(model, provider) {
   return model.startsWith(`${provider}/`) ? model.slice(provider.length + 1) : model;
 }
-function joinUrl(base, path8) {
-  return `${base.replace(/\/+$/, "")}/${path8.replace(/^\/+/, "")}`;
+function joinUrl(base, path10) {
+  return `${base.replace(/\/+$/, "")}/${path10.replace(/^\/+/, "")}`;
 }
 function configString(config, key) {
   const value = config[key];
@@ -2590,8 +2602,8 @@ var SHELL_SAFE = /^[\w.:=@+\-/\\[\]]+$/;
 function isShellSafeArg(arg) {
   return SHELL_SAFE.test(arg);
 }
-function quoteCommand(path8) {
-  return isShellSafeArg(path8) ? path8 : `"${path8}"`;
+function quoteCommand(path10) {
+  return isShellSafeArg(path10) ? path10 : `"${path10}"`;
 }
 function killTree(child) {
   if (child.pid === void 0 || child.exitCode !== null) return;
@@ -2656,12 +2668,12 @@ function runCli(opts) {
     killTree(child);
   };
   opts.signal?.addEventListener("abort", onAbort, { once: true });
-  const closed = new Promise((resolve5) => {
+  const closed = new Promise((resolve6) => {
     child.once("error", (err) => {
       spawnError = err;
-      resolve5(null);
+      resolve6(null);
     });
-    child.once("close", (code) => resolve5(code));
+    child.once("close", (code) => resolve6(code));
   });
   const exit = closed.then((code) => {
     opts.signal?.removeEventListener("abort", onAbort);
@@ -2978,7 +2990,7 @@ var ClaudeCliProvider = class {
         accountId: ctx.account.id
       });
     };
-    const abortError = () => new ProviderError("claude-cli request aborted", {
+    const abortError2 = () => new ProviderError("claude-cli request aborted", {
       kind: "timeout",
       provider: this.kind,
       accountId: ctx.account.id
@@ -3052,7 +3064,7 @@ var ClaudeCliProvider = class {
       }
     }
     const exit = await run.exit;
-    if (exit.aborted || ctx.signal?.aborted) throw abortError();
+    if (exit.aborted || ctx.signal?.aborted) throw abortError2();
     if (!finished) {
       const detail = exit.stderr.trim() || `process exited with code ${exit.code ?? "unknown"}`;
       throw fail(detail);
@@ -4035,7 +4047,7 @@ var SUBSCRIPTION_PROVIDER_KINDS = [
   "antigravity-cli",
   "gemini-web"
 ];
-var VERSION = "0.5.3";
+var VERSION = "0.6.0";
 var QUOTA_WINDOWS = ["1m", "5h", "24h"];
 var WINDOW_MS = {
   "1m": 6e4,
@@ -4299,7 +4311,7 @@ var BudgetService = class {
     const enabled = accounts.filter((a) => a.enabled);
     if (enabled.length === 0) return "";
     const available = enabled.filter((a) => a.available).length;
-    const lines = [
+    const lines2 = [
       `ACCOUNT BUDGET (${isoTime(new Date(this.clock()).toISOString())}; ${available} of ${enabled.length} accounts available).`,
       "The router already avoids exhausted accounts. When budget is scarce, keep prompts and outputs short and prefer fewer, larger steps."
     ];
@@ -4322,12 +4334,12 @@ var BudgetService = class {
         const pct = Math.round(a.remaining * 100);
         state = `${pct}% left${a.tightestWindow ? ` (${a.tightestWindow} window)` : " (provider-reported)"}`;
       }
-      lines.push(`${head}: ${state}`);
+      lines2.push(`${head}: ${state}`);
     }
     if (enabled.length > CONTEXT_ACCOUNTS) {
-      lines.push(`- \u2026and ${enabled.length - CONTEXT_ACCOUNTS} more accounts`);
+      lines2.push(`- \u2026and ${enabled.length - CONTEXT_ACCOUNTS} more accounts`);
     }
-    return lines.join("\n");
+    return lines2.join("\n");
   }
 };
 var ExperimentalDisabledError = class extends Error {
@@ -4461,11 +4473,11 @@ function cliBinaryFor(account) {
   return CLI_LOGINS[account.provider]?.binary;
 }
 var MAX_OUTPUT = 64 * 1024;
-var spawnProbe = (cmd) => new Promise((resolve5) => {
+var spawnProbe = (cmd) => new Promise((resolve6) => {
   const resolved = resolveOnPath(cmd.command, cmd.env);
   const shell = needsShell(resolved);
   if (shell && (cmd.args.some((a) => !isShellSafeArg(a)) || /["%!]/.test(resolved))) {
-    resolve5({ code: null, stdout: "" });
+    resolve6({ code: null, stdout: "" });
     return;
   }
   const options = {
@@ -4487,7 +4499,7 @@ var spawnProbe = (cmd) => new Promise((resolve5) => {
   }, cmd.timeoutMs);
   child.once("error", (err) => {
     clearTimeout(timer);
-    resolve5({
+    resolve6({
       code: null,
       stdout: "",
       missing: err.code === "ENOENT"
@@ -4495,7 +4507,7 @@ var spawnProbe = (cmd) => new Promise((resolve5) => {
   });
   child.once("close", (code) => {
     clearTimeout(timer);
-    resolve5(timedOut ? { code: null, stdout: "", timedOut } : { code, stdout });
+    resolve6(timedOut ? { code: null, stdout: "", timedOut } : { code, stdout });
   });
 });
 var ConnectionChecker = class {
@@ -5683,9 +5695,9 @@ function migrate(db, migrations = MIGRATIONS) {
   }
   return version;
 }
-function openDatabase(path8, options = {}) {
-  if (path8 !== ":memory:") mkdirSync5(dirname5(path8), { recursive: true });
-  const db = new BetterSqlite3(path8);
+function openDatabase(path10, options = {}) {
+  if (path10 !== ":memory:") mkdirSync5(dirname5(path10), { recursive: true });
+  const db = new BetterSqlite3(path10);
   try {
     db.pragma("journal_mode = WAL");
     db.pragma("foreign_keys = ON");
@@ -6374,9 +6386,9 @@ var WorkspaceTools = class {
     if (buffer.subarray(0, 8e3).includes(0)) throw new ToolInputError(`${rel} is a binary file`);
     let text = buffer.toString("utf8");
     if (args.offset !== void 0 || args.limit !== void 0) {
-      const lines = text.split("\n");
+      const lines2 = text.split("\n");
       const start = (args.offset ?? 1) - 1;
-      text = lines.slice(start, args.limit ? start + args.limit : void 0).join("\n");
+      text = lines2.slice(start, args.limit ? start + args.limit : void 0).join("\n");
     }
     if (text.length > this.maxOutput) {
       return `${text.slice(0, this.maxOutput)}
@@ -6448,9 +6460,9 @@ var WorkspaceTools = class {
       if (info2.size > MAX_FILE_BYTES) return;
       const buffer = await readFile4(file);
       if (buffer.subarray(0, 8e3).includes(0)) return;
-      const lines = buffer.toString("utf8").split("\n");
-      for (let i = 0; i < lines.length && results.length < args.max_results; i++) {
-        const line = lines[i].replace(/\r$/, "");
+      const lines2 = buffer.toString("utf8").split("\n");
+      for (let i = 0; i < lines2.length && results.length < args.max_results; i++) {
+        const line = lines2[i].replace(/\r$/, "");
         if (matcher(line)) results.push(`${rel}:${i + 1}: ${line.trim().slice(0, 300)}`);
       }
     };
@@ -6985,7 +6997,7 @@ var Git = class {
   env;
   /** Runs `git <args>` and returns stdout. Throws {@link GitError} on a non-zero exit. */
   run(args) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       execFile(
         this.binary,
         args,
@@ -7004,7 +7016,7 @@ var Git = class {
             reject(new GitError(`git ${args[0] ?? ""} failed: ${detail}`, args, code, stderr));
             return;
           }
-          resolve5(stdout);
+          resolve6(stdout);
         }
       );
     });
@@ -7163,12 +7175,12 @@ var Git = class {
     if (/\.(cmd|bat)$/i.test(gh)) {
       return { outcome: "unavailable", reason: "gh is a shell shim; refusing to pass text args" };
     }
-    const runGh = (args) => new Promise((resolve5, reject) => {
+    const runGh = (args) => new Promise((resolve6, reject) => {
       execFile(
         gh,
         args,
         { cwd: this.cwd, env: this.env, timeout: this.timeoutMs, windowsHide: true },
-        (err, stdout, stderr) => err ? reject(new Error((stderr || err.message).trim())) : resolve5(stdout.trim())
+        (err, stdout, stderr) => err ? reject(new Error((stderr || err.message).trim())) : resolve6(stdout.trim())
       );
     });
     try {
@@ -7430,17 +7442,17 @@ function statusLine(step) {
 function summarizeValidation(steps) {
   if (steps.length === 0) return "Validation PASSED: no validation commands are configured.";
   const failed = steps.filter((s) => !s.ok);
-  const lines = [
+  const lines2 = [
     failed.length === 0 ? "Validation PASSED." : `Validation FAILED (${failed.map((s) => s.name).join(", ")}).`,
     ...steps.map(statusLine)
   ];
   for (const step of failed) {
-    lines.push("", `### ${step.name} output (\`${step.command}\`)`);
-    if (step.stdout.trim()) lines.push("stdout:", "```", step.stdout.trimEnd(), "```");
-    if (step.stderr.trim()) lines.push("stderr:", "```", step.stderr.trimEnd(), "```");
-    if (!step.stdout.trim() && !step.stderr.trim()) lines.push("(no output)");
+    lines2.push("", `### ${step.name} output (\`${step.command}\`)`);
+    if (step.stdout.trim()) lines2.push("stdout:", "```", step.stdout.trimEnd(), "```");
+    if (step.stderr.trim()) lines2.push("stderr:", "```", step.stderr.trimEnd(), "```");
+    if (!step.stdout.trim() && !step.stderr.trim()) lines2.push("(no output)");
   }
-  return lines.join("\n");
+  return lines2.join("\n");
 }
 var Validator = class {
   constructor(options) {
@@ -7620,8 +7632,8 @@ var AutonomousRunner = class {
     this.stopRequested = false;
     let started = () => void 0;
     let refused = () => void 0;
-    const ready = new Promise((resolve5, reject) => {
-      started = resolve5;
+    const ready = new Promise((resolve6, reject) => {
+      started = resolve6;
       refused = reject;
     });
     this.active = (async () => {
@@ -7782,13 +7794,13 @@ var AutonomousRunner = class {
     if (this.stopRequested) throw new StopSignal();
     const controller = new AbortController();
     this.idleSleep = controller;
-    await new Promise((resolve5) => {
-      const timer = setTimeout(resolve5, ms);
+    await new Promise((resolve6) => {
+      const timer = setTimeout(resolve6, ms);
       controller.signal.addEventListener(
         "abort",
         () => {
           clearTimeout(timer);
-          resolve5();
+          resolve6();
         },
         { once: true }
       );
@@ -8079,7 +8091,7 @@ ${report}`, 4e3)
   async checkpoint() {
     if (this.stopRequested) throw new StopSignal();
     while (this.pauseRequested) {
-      await new Promise((resolve5) => this.pauseWaiters.push(resolve5));
+      await new Promise((resolve6) => this.pauseWaiters.push(resolve6));
       if (this.stopRequested) throw new StopSignal();
     }
   }
@@ -8290,8 +8302,8 @@ var AccountClient = class {
     return url.toString();
   }
   /** A page of the hosted service, such as `/login/done`. */
-  pageUrl(path8) {
-    return `${this.service.url}${path8}`;
+  pageUrl(path10) {
+    return `${this.service.url}${path10}`;
   }
   /** Browser URL that starts Google or GitHub sign-in and returns to `redirectTo` with `?code=`. */
   authorizeUrl(provider, redirectTo, challenge) {
@@ -8344,13 +8356,13 @@ var AccountClient = class {
       signal: AbortSignal.timeout(1e4)
     }).catch(() => void 0);
   }
-  async session(path8, body) {
-    return toSession(await this.post(path8, body), this.now());
+  async session(path10, body) {
+    return toSession(await this.post(path10, body), this.now());
   }
-  async post(path8, body) {
+  async post(path10, body) {
     let response;
     try {
-      response = await this.fetch(`${this.service.url}/auth/v1/${path8}`, {
+      response = await this.fetch(`${this.service.url}/auth/v1/${path10}`, {
         method: "POST",
         headers: { apikey: this.service.publishableKey, "Content-Type": "application/json" },
         body: JSON.stringify(body),
@@ -8385,8 +8397,8 @@ async function startAccountLogin(options) {
   let fail = () => {
   };
   let settled = false;
-  const session = new Promise((resolve5, reject) => {
-    finish = resolve5;
+  const session = new Promise((resolve6, reject) => {
+    finish = resolve6;
     fail = reject;
   });
   session.catch(() => {
@@ -8422,14 +8434,14 @@ async function startAccountLogin(options) {
       if (!res.headersSent) res.writeHead(500).end();
     });
   });
-  await new Promise((resolve5, reject) => {
+  await new Promise((resolve6, reject) => {
     server.once("error", reject);
-    server.listen(0, "127.0.0.1", () => resolve5());
+    server.listen(0, "127.0.0.1", () => resolve6());
   });
   const port = server.address().port;
-  const close = () => new Promise((resolve5) => {
+  const close = () => new Promise((resolve6) => {
     server.closeAllConnections();
-    server.close(() => resolve5());
+    server.close(() => resolve6());
   });
   const timeout = setTimeout(
     () => {
@@ -8570,16 +8582,16 @@ var AccountStore = class {
    * refresh goes ahead without it (the service tolerates two refreshes racing).
    */
   async lock() {
-    const path8 = `${this.path}.lock`;
+    const path10 = `${this.path}.lock`;
     const owner = `${process.pid}:${randomBytes8(8).toString("hex")}`;
-    mkdirSync7(dirname6(path8), { recursive: true });
+    mkdirSync7(dirname6(path10), { recursive: true });
     const deadline = Date.now() + LOCK_WAIT_MS;
     for (; ; ) {
       try {
-        writeFileSync3(path8, owner, { flag: "wx", mode: 384 });
+        writeFileSync3(path10, owner, { flag: "wx", mode: 384 });
         return () => {
           try {
-            if (readFileSync3(path8, "utf8") === owner) rmSync3(path8, { force: true });
+            if (readFileSync3(path10, "utf8") === owner) rmSync3(path10, { force: true });
           } catch {
           }
         };
@@ -8588,11 +8600,11 @@ var AccountStore = class {
           return () => void 0;
       }
       try {
-        if (Date.now() - statSync2(path8).mtimeMs > LOCK_STALE_MS) rmSync3(path8, { force: true });
+        if (Date.now() - statSync2(path10).mtimeMs > LOCK_STALE_MS) rmSync3(path10, { force: true });
       } catch {
       }
       if (Date.now() >= deadline) return () => void 0;
-      await new Promise((resolve5) => setTimeout(resolve5, LOCK_POLL_MS));
+      await new Promise((resolve6) => setTimeout(resolve6, LOCK_POLL_MS));
     }
   }
 };
@@ -9144,16 +9156,16 @@ ${goal.objective}`,
     );
   }
   async review(goal, roles, signal) {
-    const lines = [];
+    const lines2 = [];
     for (const task of goal.tasks) {
-      lines.push(
+      lines2.push(
         `- [${task.status}] ${task.id} (${task.role}, ${task.kind}, round ${task.round}, ${task.attempts} attempt(s)): ${task.title}`
       );
-      if (task.notes) lines.push(`  notes: ${truncateHead(task.notes, 500).replace(/\n/g, " ")}`);
+      if (task.notes) lines2.push(`  notes: ${truncateHead(task.notes, 500).replace(/\n/g, " ")}`);
       if (task.artifact) {
         const text = await this.options.store.readArtifact(goal.id, task.id);
         if (text)
-          lines.push(`  output excerpt:
+          lines2.push(`  output excerpt:
 ${indent(truncateHead(text, MAX_REVIEW_EXCERPT))}`);
       }
     }
@@ -9162,7 +9174,7 @@ ${indent(truncateHead(text, MAX_REVIEW_EXCERPT))}`);
 ${goal.objective}`,
       `Round ${goal.round} of ${goal.limits.maxRounds}. Room for ${Math.max(0, goal.limits.maxTasks - goal.tasks.length)} more task(s).`,
       `TASKS:
-${lines.join("\n")}`,
+${lines2.join("\n")}`,
       await this.sharedContext()
     ].filter(Boolean).join("\n\n");
     return this.askJson(
@@ -9649,10 +9661,10 @@ var GoalStore = class {
   }
   /** Writes a task's markdown artifact and returns its repository-relative path (`/`-separated). */
   async writeArtifact(goalId, taskId, markdown) {
-    const path8 = join7(this.goalDir(goalId), `${taskId}.md`);
-    await atomicWriteFile(path8, markdown.endsWith("\n") ? markdown : `${markdown}
+    const path10 = join7(this.goalDir(goalId), `${taskId}.md`);
+    await atomicWriteFile(path10, markdown.endsWith("\n") ? markdown : `${markdown}
 `);
-    return relative2(this.root, path8).split("\\").join("/");
+    return relative2(this.root, path10).split("\\").join("/");
   }
   async readArtifact(goalId, taskId) {
     if (!isGoalId(goalId) || !/^[-a-zA-Z0-9_]{1,64}$/.test(taskId)) return void 0;
@@ -9692,6 +9704,1531 @@ ${truncateHead(state.trim(), PROJECT_CONTEXT_CHARS)}`
   });
   return new GoalService({ orchestrator, store, lock });
 }
+var ORCHESTRATOR_AGENTS = ["claude", "codex", "agy"];
+var ORCHESTRATOR_LIMITS = {
+  objectiveMaxLength: 4e3,
+  /** Most tasks a plan may contain. */
+  maxTasks: 8,
+  /** Default when the request does not say. */
+  defaultMaxTasks: 5,
+  /** Most tasks running at the same time. */
+  maxParallel: 3,
+  /** Hard timeout for one headless agent run. */
+  taskTimeoutMs: 30 * 6e4,
+  /** Hard timeout for the planning run. */
+  planTimeoutMs: 5 * 6e4,
+  /** Longest summary kept per task (characters, head kept). */
+  summaryMaxLength: 4e3
+};
+var startRunSchema = z12.object({
+  objective: z12.string().trim().min(1).max(ORCHESTRATOR_LIMITS.objectiveMaxLength),
+  /** Defaults to every available agent. */
+  agents: z12.array(z12.enum(ORCHESTRATOR_AGENTS)).min(1).max(3).optional(),
+  maxTasks: z12.number().int().min(1).max(ORCHESTRATOR_LIMITS.maxTasks).optional(),
+  /** The agent that splits the objective. It must be installed, but need not take tasks.
+   * Defaults to the first allowed agent in the order claude, codex, agy. */
+  planner: z12.enum(ORCHESTRATOR_AGENTS).optional()
+});
+var OrchestratorError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "OrchestratorError";
+  }
+  code;
+};
+var MAX_TEXT_CHUNK = 2e3;
+var MAX_TOOL_LINE = 200;
+var MAX_ERROR = 300;
+var AGENTS = {
+  claude: {
+    label: "Claude Code",
+    binary: "claude",
+    provider: "claude-cli",
+    signIn: "run `claude` in a terminal and sign in"
+  },
+  codex: {
+    label: "Codex",
+    binary: "codex",
+    provider: "codex-cli",
+    signIn: "run `codex login` in a terminal"
+  },
+  agy: {
+    label: "Antigravity",
+    binary: "agy",
+    provider: "antigravity-cli",
+    signIn: "run `agy` in a terminal and sign in"
+  }
+};
+var AGY_PLAN_NOTE = "Note: you are running in an empty scratch directory, not inside the project, so you cannot see the repository's files. Answer from the information in this message only and do not create files.";
+function agentArgs(agent, mode) {
+  switch (agent) {
+    case "claude":
+      return mode === "plan" ? [
+        "-p",
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--permission-mode",
+        "plan",
+        "--tools",
+        "Read",
+        "Glob",
+        "Grep",
+        "--strict-mcp-config"
+      ] : ["-p", "--output-format", "stream-json", "--verbose", "--permission-mode", "acceptEdits"];
+    case "codex":
+      return [
+        "exec",
+        "--json",
+        "--skip-git-repo-check",
+        "--sandbox",
+        mode === "plan" ? "read-only" : "workspace-write",
+        "-c",
+        "approval_policy=never",
+        "-"
+      ];
+    case "agy":
+      return [
+        "--input-format",
+        "stream-json",
+        "--output-format",
+        "stream-json",
+        "--sandbox",
+        "--disable-slash-commands",
+        "--print="
+      ];
+  }
+}
+function realPath(p) {
+  try {
+    return realpathSync.native(p);
+  } catch {
+    return path8.resolve(p);
+  }
+}
+function agentStdin(agent, mode, prompt) {
+  if (agent === "agy") {
+    const content = mode === "plan" ? `${AGY_PLAN_NOTE}
+
+${prompt}` : prompt;
+    return `${JSON.stringify({ event: "user", message: { content } })}
+`;
+  }
+  if (agent === "claude" && prompt.trimStart().startsWith("/")) return `Task:
+${prompt}`;
+  return prompt;
+}
+function abortError() {
+  const err = new Error("The agent run was aborted");
+  err.name = "AbortError";
+  return err;
+}
+var SECRET_PATTERNS = [
+  [/\b(?:sk|rk|pk)-[A-Za-z0-9_-]{8,}/g, "[redacted]"],
+  [/\b(?:ghp|gho|ghs|ghu|github_pat)_[A-Za-z0-9_]{8,}/g, "[redacted]"],
+  [/\bAIza[A-Za-z0-9_-]{20,}/g, "[redacted]"],
+  [/\bya29\.[A-Za-z0-9._-]{10,}/g, "[redacted]"],
+  [/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]*/g, "[redacted]"],
+  [/\b(bearer)\s+[^\s"']+/gi, "$1 [redacted]"],
+  [
+    /\b(api[_-]?key|access[_-]?token|refresh[_-]?token|token|secret|password|authorization)(["']?\s*[:=]\s*["']?)[^\s"',}]+/gi,
+    "$1$2[redacted]"
+  ]
+];
+function scrubSecrets(text) {
+  let out = redact(text);
+  for (const [pattern, replacement] of SECRET_PATTERNS) out = out.replace(pattern, replacement);
+  return out.replace(/\s+/g, " ").trim();
+}
+function clip(text, max) {
+  return text.length <= max ? text : `${text.slice(0, max - 1)}\u2026`;
+}
+function shortError(text) {
+  return clip(scrubSecrets(text), MAX_ERROR);
+}
+function formatDuration(ms) {
+  if (ms >= 6e4) return `${Math.round(ms / 6e4)} min`;
+  return `${Math.max(1, Math.ceil(ms / 1e3))} s`;
+}
+function tail(text, max = 400) {
+  const t = text.trim();
+  return t.length <= max ? t : t.slice(t.length - max);
+}
+function toolLine(name, input, cwd) {
+  let hint;
+  if (isRecord(input)) {
+    const lower = new Map(Object.entries(input).map(([k, v]) => [k.toLowerCase(), v]));
+    for (const key of [
+      "file_path",
+      "filepath",
+      "absolutepath",
+      "path",
+      "targetfile",
+      "command",
+      "commandline",
+      "cmd",
+      "pattern",
+      "query",
+      "url",
+      "description"
+    ]) {
+      const value = lower.get(key);
+      const str2 = typeof value === "string" ? value : Array.isArray(value) ? value.join(" ") : "";
+      if (str2.trim()) {
+        hint = str2;
+        break;
+      }
+    }
+  }
+  if (hint && path8.isAbsolute(hint)) {
+    for (const base of /* @__PURE__ */ new Set([cwd, realPath(cwd)])) {
+      const rel = path8.relative(base, hint);
+      if (rel && !rel.startsWith("..") && !path8.isAbsolute(rel)) {
+        hint = rel.split(path8.sep).join("/");
+        break;
+      }
+    }
+  }
+  return clip(scrubSecrets(hint ? `${name} ${hint}` : name), MAX_TOOL_LINE);
+}
+function claudeParser(emit, cwd) {
+  const state = { text: "", completed: false };
+  let lastAssistant = "";
+  return {
+    state,
+    flush() {
+    },
+    handle(raw) {
+      if (!isRecord(raw)) return;
+      const type = asString(raw.type);
+      if (type === "system" && raw.subtype === "init") {
+        const model = asString(raw.model);
+        emit({
+          kind: "status",
+          text: model ? `Claude Code started (${model})` : "Claude Code started"
+        });
+        return;
+      }
+      if (type === "assistant" && raw.parent_tool_use_id == null && isRecord(raw.message)) {
+        const texts = [];
+        for (const block of asArray(raw.message.content)) {
+          if (!isRecord(block)) continue;
+          if (block.type === "text") {
+            const t = asString(block.text)?.trim();
+            if (t) texts.push(t);
+          } else if (block.type === "tool_use") {
+            emit({
+              kind: "tool",
+              text: toolLine(asString(block.name) ?? "tool", block.input, cwd)
+            });
+          }
+        }
+        if (texts.length > 0) {
+          lastAssistant = texts.join("\n");
+          emit({ kind: "text", text: clip(lastAssistant, MAX_TEXT_CHUNK) });
+        }
+        return;
+      }
+      if (type === "result") {
+        const result = asString(raw.result) ?? "";
+        const subtype = asString(raw.subtype) ?? "success";
+        const u = isRecord(raw.usage) ? raw.usage : void 0;
+        if (u) {
+          state.tokens = (asNumber(u.input_tokens) ?? 0) + (asNumber(u.cache_creation_input_tokens) ?? 0) + (asNumber(u.cache_read_input_tokens) ?? 0) + (asNumber(u.output_tokens) ?? 0);
+        }
+        if (raw.is_error === true || subtype !== "success") {
+          state.failure = result || `Claude Code reported ${subtype}`;
+          return;
+        }
+        state.completed = true;
+        state.text = result || lastAssistant;
+      }
+    }
+  };
+}
+function codexErrorText(value) {
+  if (typeof value === "string") return value;
+  if (isRecord(value)) return asString(value.message) ?? JSON.stringify(value);
+  return void 0;
+}
+function codexItemLine(item, cwd) {
+  const type = asString(item.type) ?? "item";
+  switch (type) {
+    case "reasoning":
+    case "todo_list":
+      return void 0;
+    case "command_execution":
+      return toolLine("Run", { command: asString(item.command) ?? "" }, cwd);
+    case "file_change": {
+      const files = asArray(item.changes).flatMap((c) => isRecord(c) && asString(c.path) ? [asString(c.path)] : []).map((f) => toolLine("", { path: f }, cwd).trim());
+      return clip(`Edit ${files.join(", ")}`.trim(), MAX_TOOL_LINE);
+    }
+    case "mcp_tool_call": {
+      const name = [asString(item.server), asString(item.tool)].filter(Boolean).join(".");
+      return toolLine(name || "MCP tool", void 0, cwd);
+    }
+    case "web_search":
+      return toolLine("Search", { query: asString(item.query) ?? "" }, cwd);
+    default:
+      return toolLine(type, item, cwd);
+  }
+}
+function codexParser(emit, cwd) {
+  const state = { text: "", completed: false };
+  const announced = /* @__PURE__ */ new Set();
+  let lastError;
+  return {
+    state,
+    flush() {
+      if (!state.completed && !state.failure && lastError) state.failure = lastError;
+    },
+    handle(raw) {
+      if (!isRecord(raw)) return;
+      const ev = isRecord(raw.msg) ? raw.msg : raw;
+      const type = asString(ev.type) ?? "";
+      if (type === "thread.started") {
+        emit({ kind: "status", text: "Codex started" });
+        return;
+      }
+      if ((type === "item.started" || type === "item.completed") && isRecord(ev.item)) {
+        const item = ev.item;
+        const itemType = asString(item.type);
+        if (itemType === "agent_message" || itemType === "assistant_message") {
+          if (type !== "item.completed") return;
+          const text = (asString(item.text) ?? asString(item.message) ?? "").trim();
+          if (text) {
+            state.text = text;
+            emit({ kind: "text", text: clip(text, MAX_TEXT_CHUNK) });
+          }
+          return;
+        }
+        if (itemType === "error") {
+          const message = asString(item.message);
+          if (message && type === "item.completed")
+            emit({ kind: "error", text: shortError(message) });
+          return;
+        }
+        const id = asString(item.id) ?? `${itemType}-${announced.size}`;
+        if (itemType === "file_change" && type !== "item.completed") return;
+        if (announced.has(id)) return;
+        announced.add(id);
+        const line = codexItemLine(item, cwd);
+        if (line) emit({ kind: "tool", text: line });
+        return;
+      }
+      if (type === "turn.completed" || type === "task_complete") {
+        state.completed = true;
+        const last = asString(ev.last_agent_message);
+        if (!state.text && last) state.text = last;
+        const u = isRecord(ev.usage) ? ev.usage : void 0;
+        if (u) state.tokens = (asNumber(u.input_tokens) ?? 0) + (asNumber(u.output_tokens) ?? 0);
+        return;
+      }
+      if (type === "turn.failed") {
+        state.failure = codexErrorText(ev.error) ?? lastError ?? "Codex reported an error";
+        return;
+      }
+      if (type === "error") {
+        lastError = codexErrorText(ev.message) ?? codexErrorText(ev.error) ?? lastError;
+        if (lastError) emit({ kind: "error", text: shortError(lastError) });
+        return;
+      }
+      if (type === "agent_message") {
+        const text = (asString(ev.message) ?? "").trim();
+        if (text) {
+          state.text = text;
+          emit({ kind: "text", text: clip(text, MAX_TEXT_CHUNK) });
+        }
+      }
+    }
+  };
+}
+function agyParser(emit, cwd) {
+  const state = { text: "", completed: false };
+  const announced = /* @__PURE__ */ new Set();
+  let streamed = "";
+  let buffer = "";
+  let bufferStep;
+  const flushText = () => {
+    const text = buffer.trim();
+    buffer = "";
+    bufferStep = void 0;
+    if (text) emit({ kind: "text", text: clip(text, MAX_TEXT_CHUNK) });
+  };
+  return {
+    state,
+    flush: flushText,
+    handle(raw) {
+      if (!isRecord(raw)) return;
+      const event = asString(raw.event);
+      if (event === "init") {
+        emit({ kind: "status", text: "Antigravity started" });
+        return;
+      }
+      if (event === "step_update" && isRecord(raw.step_update)) {
+        const step = raw.step_update;
+        const stepType = asString(step.step_type);
+        const index = String(asNumber(step.step_index) ?? asString(step.step_index) ?? "");
+        if (stepType === "agent_response") {
+          if (bufferStep !== void 0 && bufferStep !== index) flushText();
+          const delta = asString(step.text_delta);
+          if (delta) {
+            bufferStep = index;
+            buffer += delta;
+            streamed += delta;
+          }
+          if (asString(step.state) === "DONE") flushText();
+          return;
+        }
+        if (stepType === "tool") {
+          flushText();
+          if (announced.has(index)) return;
+          announced.add(index);
+          const info = isRecord(step.tool_info) ? step.tool_info : {};
+          const name = asString(step.tool_name) ?? asString(info.name) ?? "tool";
+          emit({ kind: "tool", text: toolLine(name, info.parameters, cwd) });
+        }
+        return;
+      }
+      if (event === "result" && isRecord(raw.result)) {
+        flushText();
+        const result = raw.result;
+        const u = isRecord(result.usage) ? result.usage : void 0;
+        if (u) {
+          state.tokens = (asNumber(u.input_tokens) ?? 0) + (asNumber(u.output_tokens) ?? 0) + (asNumber(u.thinking_tokens) ?? 0);
+        }
+        const status = asString(result.status);
+        if (status !== "SUCCESS") {
+          state.failure = asString(result.error) ?? `Antigravity ended with ${status ?? "an error"}`;
+          return;
+        }
+        state.completed = true;
+        state.text = (asString(result.response) ?? streamed).trim();
+      }
+    }
+  };
+}
+var PARSERS = {
+  claude: claudeParser,
+  codex: codexParser,
+  agy: agyParser
+};
+function failureMessage(info, detail, evidence, code) {
+  const { kind } = classifyCliText(evidence);
+  if (kind === "auth") return `${info.label} is not signed in: ${info.signIn}`;
+  const clean = scrubSecrets(detail);
+  if (kind === "quota_exhausted") return shortError(`${info.label} usage limit reached: ${clean}`);
+  if (kind === "rate_limit") return shortError(`${info.label} is rate limited: ${clean}`);
+  const exit = code !== null && code !== 0 ? ` (exit ${code})` : "";
+  return shortError(`${info.label} failed${exit}${clean ? `: ${clean}` : ""}`);
+}
+function createCliAgentRunner(options = {}) {
+  const env = options.env ?? process.env;
+  const childEnv = {};
+  for (const [k, v] of Object.entries(env)) if (typeof v === "string") childEnv[k] = v;
+  const resolveBinary = (agent) => {
+    const override = options.binaries?.[agent];
+    const command = override?.command ?? AGENTS[agent].binary;
+    return { command: resolveOnPath(command, env), prefix: override?.args ?? [] };
+  };
+  const isAvailable = (agent) => {
+    const { command } = resolveBinary(agent);
+    if (!path8.isAbsolute(command)) return false;
+    try {
+      return existsSync4(command) && statSync3(command).isFile();
+    } catch {
+      return false;
+    }
+  };
+  async function run(request) {
+    if (request.signal.aborted) throw abortError();
+    const info = AGENTS[request.agent];
+    const { command, prefix } = resolveBinary(request.agent);
+    const args = agentArgs(request.agent, request.mode);
+    if (needsShell(command) && ![...prefix, ...args].every(isShellSafeArg)) {
+      return { ok: false, text: "", error: `${info.label}: unsafe argument for the Windows shell` };
+    }
+    const emit = (chunk) => {
+      try {
+        request.onOutput(chunk);
+      } catch {
+      }
+    };
+    let scratch;
+    let cwd = request.cwd;
+    if (request.agent === "agy" && request.mode === "plan") {
+      scratch = mkdtempSync(path8.join(options.scratchDir ?? tmpdir(), "davecode-agy-plan-"));
+      cwd = scratch;
+    }
+    const timeout = AbortSignal.timeout(request.timeoutMs);
+    const signal = AbortSignal.any([request.signal, timeout]);
+    const timedOut = () => ({
+      ok: false,
+      text: "",
+      error: `${info.label} timed out after ${formatDuration(request.timeoutMs)}`
+    });
+    try {
+      let cli;
+      try {
+        cli = runCli({
+          provider: info.provider,
+          accountId: "orchestrator",
+          settings: { command, prefixArgs: prefix },
+          args,
+          env: childEnv,
+          cwd,
+          stdin: agentStdin(request.agent, request.mode, request.prompt),
+          signal
+        });
+      } catch (err) {
+        if (request.signal.aborted) throw abortError();
+        if (timeout.aborted) return timedOut();
+        return { ok: false, text: "", error: shortError(errText(err)) };
+      }
+      const parser = PARSERS[request.agent](emit, cwd);
+      let streamError;
+      try {
+        for await (const event of cli.events) parser.handle(event);
+      } catch (err) {
+        streamError = errText(err);
+      }
+      parser.flush();
+      let exit;
+      try {
+        exit = await cli.exit;
+      } catch {
+        if (request.signal.aborted) throw abortError();
+        return {
+          ok: false,
+          text: "",
+          error: `${info.label} could not be started: is \`${info.binary}\` installed and on PATH?`
+        };
+      }
+      if (request.signal.aborted) throw abortError();
+      if (exit.aborted || timeout.aborted) return { ...timedOut(), text: parser.state.text };
+      const { state } = parser;
+      if (state.completed && !state.failure && exit.code === 0) {
+        return {
+          ok: true,
+          text: state.text,
+          ...state.tokens !== void 0 ? { tokens: state.tokens } : {}
+        };
+      }
+      const detail = state.failure ?? streamError ?? (tail(exit.stderr) || (exit.code === 0 ? "the CLI ended without a final result" : "no output"));
+      return {
+        ok: false,
+        text: state.text,
+        error: failureMessage(info, detail, `${detail}
+${tail(exit.stderr)}`, exit.code),
+        ...state.tokens !== void 0 ? { tokens: state.tokens } : {}
+      };
+    } finally {
+      if (scratch) {
+        try {
+          rmSync4(scratch, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+        } catch {
+        }
+      }
+    }
+  }
+  return {
+    async availability() {
+      return ORCHESTRATOR_AGENTS.map((agent) => ({ agent, available: isAvailable(agent) }));
+    },
+    run
+  };
+}
+function errText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+var AGENT_DESCRIPTIONS = {
+  claude: "Claude Code (Anthropic): careful multi-file changes, refactors and reasoning about existing code.",
+  codex: "Codex CLI (OpenAI): focused implementation work, scripts, tests and quick fixes.",
+  agy: "Antigravity (Google): broad feature work, front-end and UI changes, exploratory tasks."
+};
+var TITLE_MAX_LENGTH = 120;
+var PROMPT_MAX_LENGTH = 8e3;
+var REPAIR_REPLY_MAX_LENGTH = 6e3;
+function pickPlanner(agents) {
+  return ORCHESTRATOR_AGENTS.find((agent) => agents.includes(agent));
+}
+var REPLY_SHAPE = '{"tasks":[{"title":string,"agent":"claude"|"codex"|"agy","prompt":string,"dependsOn":[number]}]}';
+function buildPlanPrompt(input) {
+  const agentLines = input.agents.map((agent) => `- ${agent}: ${AGENT_DESCRIPTIONS[agent]}`);
+  return [
+    "You are the planner of DaveCode, which splits one objective across several coding agents.",
+    "Do not change any file. Read the repository as much as you need, then answer with a plan.",
+    "",
+    "Objective:",
+    input.objective,
+    "",
+    "Agents you may assign tasks to:",
+    ...agentLines,
+    "",
+    "Rules:",
+    `- Use at most ${input.maxTasks} task${input.maxTasks === 1 ? "" : "s"}. Fewer is better when the objective is small.`,
+    "- Tasks run in parallel, each in its own separate copy of the repository, and their changes are merged afterwards. Give tasks different files to touch wherever possible so the merges do not conflict.",
+    '- When a task needs the result of another task, list it in "dependsOn" (1-based positions in the "tasks" array). It then starts only after those tasks finished and were merged.',
+    '- Each "prompt" must be self-contained: the agent sees only its own prompt and the repository, not this plan or the other prompts. Say exactly what to build or change, where, and how to know it is done.',
+    '- Write every "title" and "prompt" in the language of the objective.',
+    "- Spread the work over the agents according to their strengths.",
+    "",
+    "Reply with ONLY a JSON object, no prose and no code fence, of this shape:",
+    REPLY_SHAPE
+  ].join("\n");
+}
+function buildRepairPrompt(input, previousReply, error) {
+  const reply = previousReply.length > REPAIR_REPLY_MAX_LENGTH ? `${previousReply.slice(0, REPAIR_REPLY_MAX_LENGTH)}\u2026` : previousReply;
+  return [
+    "Your previous plan could not be used.",
+    `Problem: ${error}`,
+    "",
+    "Your previous reply:",
+    reply.trim() || "(empty)",
+    "",
+    `Objective: ${input.objective}`,
+    `Allowed agents: ${input.agents.join(", ")}. At most ${input.maxTasks} tasks, at least one.`,
+    "Dependencies are 1-based task positions and must not form a cycle.",
+    "Do not change any file. Reply with ONLY a JSON object of this shape:",
+    REPLY_SHAPE
+  ].join("\n");
+}
+function buildTaskPrompt(input) {
+  const others = input.tasks.filter((t) => t.id !== input.task.id);
+  const deps = input.tasks.filter((t) => input.task.dependsOn.includes(t.id));
+  const lines2 = [
+    "You are one of several coding agents working together on one objective, coordinated by DaveCode.",
+    "",
+    "Overall objective:",
+    input.objective,
+    "",
+    `Your task: ${input.task.title}`,
+    input.task.prompt,
+    ""
+  ];
+  if (deps.length > 0) {
+    lines2.push(
+      "The results of these tasks are already in your copy of the repository:",
+      ...deps.map((t) => `- ${t.title}`),
+      ""
+    );
+  }
+  if (others.length > 0) {
+    lines2.push(
+      "Other agents work on these parts in parallel, in their own copies of the repository:",
+      ...others.map((t) => `- ${t.title} (${t.agent})`),
+      ""
+    );
+  }
+  lines2.push(
+    "Rules:",
+    "- Keep to the scope of your task; leave the other parts to the other agents.",
+    "- Do not commit, push, create or switch branches. DaveCode commits and merges your changes.",
+    "- Do not read or modify anything under `.davecode/`.",
+    "- When you are done, finish with a short summary of what you changed and anything left open."
+  );
+  return lines2.join("\n");
+}
+var dependencySchema = z13.union([z13.number(), z13.string()]);
+var plannedTaskSchema2 = z13.object({
+  title: z13.string().trim().min(1),
+  agent: z13.string().optional(),
+  prompt: z13.string().trim().min(1),
+  dependsOn: z13.array(dependencySchema).nullish()
+});
+var planReplySchema = z13.object({
+  tasks: z13.array(plannedTaskSchema2).min(1, "the plan has no tasks")
+});
+function dependencyIndex(value) {
+  if (typeof value === "number") return Number.isInteger(value) ? value : void 0;
+  const match = /^\s*t?(\d+)\s*$/i.exec(value);
+  return match?.[1] ? Number(match[1]) : void 0;
+}
+function clip2(text, max) {
+  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+}
+function describeZodError(error) {
+  const issue = error.issues[0];
+  if (!issue) return "the reply does not match the expected shape";
+  const path10 = issue.path.length > 0 ? `${issue.path.join(".")}: ` : "";
+  return `${path10}${issue.message}`;
+}
+function findCycle(tasks) {
+  const byId = new Map(tasks.map((t) => [t.id, t]));
+  const done = /* @__PURE__ */ new Set();
+  const stack = [];
+  const onStack = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    stack.push(id);
+    onStack.add(id);
+    for (const dep of byId.get(id)?.dependsOn ?? []) {
+      if (onStack.has(dep)) return [...stack.slice(stack.indexOf(dep)), dep];
+      if (!done.has(dep) && byId.has(dep)) {
+        const cycle = visit(dep);
+        if (cycle) return cycle;
+      }
+    }
+    stack.pop();
+    onStack.delete(id);
+    done.add(id);
+    return void 0;
+  };
+  for (const task of tasks) {
+    if (done.has(task.id)) continue;
+    const cycle = visit(task.id);
+    if (cycle) return cycle;
+  }
+  return void 0;
+}
+function parsePlan(text, options) {
+  if (options.agents.length === 0) return { ok: false, error: "no agents are allowed" };
+  let raw;
+  try {
+    raw = extractJsonObject(text);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: `the reply is not a valid JSON object (${clip2(reason, 120)})` };
+  }
+  const parsed = planReplySchema.safeParse(raw);
+  if (!parsed.success) return { ok: false, error: describeZodError(parsed.error) };
+  const maxTasks = Math.max(1, Math.min(options.maxTasks, ORCHESTRATOR_LIMITS.maxTasks));
+  const planned = parsed.data.tasks.slice(0, maxTasks);
+  let roundRobin = 0;
+  const tasks = planned.map((p, index) => {
+    const allowed = options.agents.find((a) => a === p.agent?.trim().toLowerCase());
+    const agent = allowed ?? options.agents[roundRobin++ % options.agents.length];
+    const deps = /* @__PURE__ */ new Set();
+    for (const value of p.dependsOn ?? []) {
+      const dep = dependencyIndex(value);
+      if (dep === void 0 || dep < 1 || dep > planned.length || dep === index + 1) continue;
+      deps.add(`t${dep}`);
+    }
+    return {
+      id: `t${index + 1}`,
+      title: clip2(p.title.replace(/\s+/g, " "), TITLE_MAX_LENGTH),
+      agent,
+      prompt: clip2(p.prompt, PROMPT_MAX_LENGTH),
+      dependsOn: [...deps],
+      status: "pending"
+    };
+  });
+  const cycle = findCycle(tasks);
+  if (cycle) {
+    return { ok: false, error: `the dependencies form a cycle (${cycle.join(" -> ")})` };
+  }
+  return { ok: true, tasks };
+}
+var ORCHESTRATOR_RUNS_KEPT = 20;
+var agentSchema = z14.enum(ORCHESTRATOR_AGENTS);
+var taskSchema = z14.object({
+  id: z14.string().min(1),
+  title: z14.string(),
+  agent: agentSchema,
+  prompt: z14.string(),
+  dependsOn: z14.array(z14.string()),
+  status: z14.enum(["pending", "running", "done", "failed", "conflict", "cancelled", "skipped"]),
+  branch: z14.string().optional(),
+  summary: z14.string().optional(),
+  changedFiles: z14.array(z14.string()).optional(),
+  error: z14.string().optional(),
+  startedAt: z14.string().optional(),
+  finishedAt: z14.string().optional()
+});
+var orchestratorRunSchema = z14.object({
+  id: z14.string().min(1),
+  objective: z14.string(),
+  status: z14.enum(["planning", "running", "done", "failed", "cancelled"]),
+  agents: z14.array(agentSchema),
+  planner: agentSchema.optional(),
+  baseBranch: z14.string().optional(),
+  baseCommit: z14.string().optional(),
+  integrationBranch: z14.string().optional(),
+  tasks: z14.array(taskSchema),
+  summary: z14.string().optional(),
+  error: z14.string().optional(),
+  appliedAt: z14.string().optional(),
+  createdAt: z14.string(),
+  updatedAt: z14.string()
+});
+var fileSchema2 = z14.object({
+  version: z14.literal(1),
+  runs: z14.array(z14.unknown())
+});
+function orchestratorRunsPath(home, projectDir) {
+  let key = resolve5(projectDir);
+  if (process.platform === "win32") key = key.toLowerCase();
+  const hash = createHash3("sha256").update(key).digest("hex").slice(0, 16);
+  return join8(home, "orchestrator", hash, "runs.json");
+}
+function newestFirst(runs) {
+  return [...runs].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+var OrchestratorStore = class {
+  path;
+  queued;
+  writing;
+  constructor(home, projectDir) {
+    this.path = orchestratorRunsPath(home, projectDir);
+  }
+  /**
+   * The stored runs, newest first. A missing or corrupt file yields no runs; a run that does not
+   * validate is skipped.
+   */
+  load() {
+    let text;
+    try {
+      text = readFileSync4(this.path, "utf8");
+    } catch {
+      return [];
+    }
+    let file;
+    try {
+      file = fileSchema2.parse(JSON.parse(text));
+    } catch {
+      return [];
+    }
+    const runs = [];
+    for (const entry of file.runs) {
+      const parsed = orchestratorRunSchema.safeParse(entry);
+      if (parsed.success) runs.push(parsed.data);
+    }
+    return newestFirst(runs).slice(0, ORCHESTRATOR_RUNS_KEPT);
+  }
+  /**
+   * Snapshots `runs` now and writes them atomically in the background, keeping the newest
+   * {@link ORCHESTRATOR_RUNS_KEPT}. Writes are serialized; a snapshot that is still queued is
+   * replaced by the newer one. Resolves once that snapshot (or a newer one) is on disk; never
+   * rejects (a failed write is retried by the next save).
+   */
+  save(runs) {
+    const kept = newestFirst(runs).slice(0, ORCHESTRATOR_RUNS_KEPT);
+    this.queued = `${JSON.stringify({ version: 1, runs: kept }, null, 2)}
+`;
+    if (!this.writing) {
+      this.writing = this.drain().finally(() => {
+        this.writing = void 0;
+      });
+    }
+    return this.writing;
+  }
+  /** Waits for every queued write. */
+  async flush() {
+    while (this.writing) await this.writing;
+  }
+  async drain() {
+    while (this.queued !== void 0) {
+      const content = this.queued;
+      this.queued = void 0;
+      try {
+        await atomicWriteFile(this.path, content);
+      } catch {
+      }
+    }
+  }
+};
+var ERROR_MAX_LENGTH = 300;
+var OUTPUT_MAX_LENGTH = 2e3;
+var RUNS_KEPT = 20;
+var INTERRUPTED_ERROR = "Interrupted: DaveCode closed while this run was active.";
+var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["planning", "running"]);
+var RunFailure = class extends Error {
+};
+function clip3(text, max) {
+  const trimmed = text.trim();
+  return trimmed.length > max ? `${trimmed.slice(0, max - 1)}\u2026` : trimmed;
+}
+function errorText3(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return clip3(message || "unknown error", ERROR_MAX_LENGTH);
+}
+function isAbortError(err) {
+  return typeof err === "object" && err !== null && "name" in err && (err.name === "AbortError" || err.name === "TimeoutError");
+}
+var Queue = class {
+  tail = Promise.resolve();
+  run(work) {
+    const next = this.tail.then(work, work);
+    this.tail = next.catch(() => void 0);
+    return next;
+  }
+};
+var isActive = (run) => ACTIVE_STATUSES.has(run.status);
+function createOrchestratorService(options) {
+  return new OrchestratorEngine(options);
+}
+var OrchestratorEngine = class {
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.newId = options.newId ?? (() => randomBytes9(6).toString("hex"));
+    this.store = new OrchestratorStore(options.home, options.projectDir);
+    this.runs = this.store.load();
+    this.recoverInterrupted();
+  }
+  options;
+  now;
+  newId;
+  store;
+  /** Newest first. */
+  runs;
+  active = /* @__PURE__ */ new Map();
+  applying = /* @__PURE__ */ new Set();
+  /** A `start` that passed the busy check but has not registered its run yet. */
+  starting = false;
+  /** Every git mutation goes through here: worktree, commit and merge must not interleave. */
+  git = new Queue();
+  // --- Public API ------------------------------------------------------------------------------
+  agents() {
+    return this.options.runner.availability();
+  }
+  async start(rawInput) {
+    const input = startRunSchema.parse(rawInput);
+    this.assertIdle();
+    this.starting = true;
+    try {
+      const { workspace, runner } = this.options;
+      let head;
+      try {
+        const checked = await workspace.check();
+        if (!checked.ok) throw new OrchestratorError("not_a_repository", clip3(checked.reason, 300));
+        head = { branch: checked.branch, commit: checked.commit };
+      } catch (err) {
+        if (err instanceof OrchestratorError) throw err;
+        throw new OrchestratorError("not_a_repository", errorText3(err));
+      }
+      const availability = await runner.availability();
+      const available = new Set(availability.filter((a) => a.available).map((a) => a.agent));
+      const wanted = new Set(input.agents ?? ORCHESTRATOR_AGENTS);
+      const agents = ORCHESTRATOR_AGENTS.filter((a) => wanted.has(a) && available.has(a));
+      if (agents.length === 0) {
+        throw new OrchestratorError(
+          "no_agents",
+          input.agents ? `None of the selected agents (${input.agents.join(", ")}) is installed.` : "No agent CLI (claude, codex, agy) was found on PATH."
+        );
+      }
+      if (input.planner && !available.has(input.planner)) {
+        throw new OrchestratorError(
+          "no_agents",
+          `The chosen planner (${input.planner}) is not installed.`
+        );
+      }
+      const planner = input.planner ?? pickPlanner(agents);
+      const id = this.newId();
+      let integrationBranch;
+      try {
+        integrationBranch = await this.git.run(() => workspace.createIntegration(id, head.commit));
+      } catch (err) {
+        throw new OrchestratorError("not_a_repository", errorText3(err));
+      }
+      const stamp = this.stamp();
+      const run = {
+        id,
+        objective: input.objective,
+        status: "planning",
+        agents,
+        planner,
+        baseBranch: head.branch,
+        baseCommit: head.commit,
+        integrationBranch,
+        tasks: [],
+        createdAt: stamp,
+        updatedAt: stamp
+      };
+      this.runs.unshift(run);
+      this.trim();
+      const active = {
+        run,
+        controller: new AbortController(),
+        done: Promise.resolve()
+      };
+      this.active.set(id, active);
+      this.changed(run);
+      active.done = this.execute(active, input.maxTasks ?? ORCHESTRATOR_LIMITS.defaultMaxTasks).catch(() => void 0).finally(() => {
+        this.active.delete(id);
+      });
+      return structuredClone(run);
+    } finally {
+      this.starting = false;
+    }
+  }
+  get(id) {
+    const run = this.find(id);
+    return run ? structuredClone(run) : void 0;
+  }
+  list() {
+    return this.runs.map((run) => structuredClone(run));
+  }
+  cancel(id) {
+    const active = this.active.get(id);
+    if (!active || !isActive(active.run)) return false;
+    active.controller.abort();
+    return true;
+  }
+  async apply(id) {
+    const run = this.find(id);
+    if (!run) throw new OrchestratorError("not_found", `No orchestrator run ${id}.`);
+    if (run.status !== "done") {
+      throw new OrchestratorError(
+        "not_appliable",
+        `The run is ${run.status}; only a finished run can be applied.`
+      );
+    }
+    if (run.appliedAt) throw new OrchestratorError("not_appliable", "The run was already applied.");
+    if (!run.integrationBranch || !run.baseBranch) {
+      throw new OrchestratorError("not_appliable", "The run has no integration branch to apply.");
+    }
+    if (this.applying.has(id)) {
+      throw new OrchestratorError("not_appliable", "The run is already being applied.");
+    }
+    const baseBranch = run.baseBranch;
+    this.applying.add(id);
+    try {
+      let result;
+      try {
+        result = await this.git.run(() => this.options.workspace.apply(id, baseBranch));
+      } catch (err) {
+        result = { ok: false, reason: errorText3(err) };
+      }
+      if (!result.ok) throw new OrchestratorError("not_appliable", clip3(result.reason, 300));
+      run.appliedAt = this.stamp();
+      this.changed(run);
+      return structuredClone(run);
+    } finally {
+      this.applying.delete(id);
+    }
+  }
+  async close() {
+    const pending = [...this.active.values()];
+    for (const active of pending) active.controller.abort();
+    await Promise.all(pending.map((active) => active.done));
+    await this.store.flush();
+  }
+  // --- Run lifecycle ---------------------------------------------------------------------------
+  async execute(active, maxTasks) {
+    const { run, controller } = active;
+    try {
+      run.tasks = await this.plan(active, maxTasks);
+      if (controller.signal.aborted) throw controller.signal.reason;
+      run.status = "running";
+      this.changed(run);
+      await this.runTasks(active);
+      this.finish(run, controller.signal.aborted);
+    } catch (err) {
+      if (controller.signal.aborted || isAbortError(err)) {
+        this.finish(run, true);
+      } else {
+        for (const task of run.tasks) this.endTask(task, "cancelled");
+        run.status = "failed";
+        run.error = errorText3(err);
+        run.summary = `The run failed: ${run.error}`;
+        this.changed(run);
+      }
+    } finally {
+      try {
+        await this.options.workspace.cleanup(run.id);
+      } catch {
+      }
+    }
+  }
+  async plan(active, maxTasks) {
+    const { run } = active;
+    const planner = run.planner;
+    const promptInput = { objective: run.objective, agents: run.agents, maxTasks };
+    const ask = async (prompt) => {
+      const result = await this.options.runner.run({
+        agent: planner,
+        cwd: this.options.projectDir,
+        prompt,
+        mode: "plan",
+        signal: active.controller.signal,
+        timeoutMs: ORCHESTRATOR_LIMITS.planTimeoutMs,
+        onOutput: (chunk) => this.output(run.id, "plan", chunk)
+      });
+      if (!result.ok) {
+        throw new RunFailure(
+          `The planner (${planner}) failed: ${result.error ?? "no reason given"}`
+        );
+      }
+      return result;
+    };
+    this.output(run.id, "plan", { kind: "status", text: `Planning with ${planner}\u2026` });
+    const first = await ask(buildPlanPrompt(promptInput));
+    const parsed = parsePlan(first.text, { agents: run.agents, maxTasks });
+    if (parsed.ok) return parsed.tasks;
+    this.output(run.id, "plan", {
+      kind: "status",
+      text: `The plan was not usable (${parsed.error}); asking ${planner} to fix it.`
+    });
+    const second = await ask(buildRepairPrompt(promptInput, first.text, parsed.error));
+    const repaired = parsePlan(second.text, { agents: run.agents, maxTasks });
+    if (repaired.ok) return repaired.tasks;
+    throw new RunFailure(`The planner did not return a usable plan: ${repaired.error}`);
+  }
+  async runTasks(active) {
+    const { run, controller } = active;
+    const running = /* @__PURE__ */ new Map();
+    const busyAgents = /* @__PURE__ */ new Set();
+    while (!controller.signal.aborted) {
+      this.skipBlocked(run);
+      for (const task of run.tasks) {
+        if (running.size >= ORCHESTRATOR_LIMITS.maxParallel) break;
+        if (task.status !== "pending" || busyAgents.has(task.agent)) continue;
+        if (!task.dependsOn.every((dep) => this.taskById(run, dep)?.status === "done")) continue;
+        busyAgents.add(task.agent);
+        const work = this.runTask(active, task).finally(() => {
+          running.delete(task.id);
+          busyAgents.delete(task.agent);
+        });
+        running.set(task.id, work);
+      }
+      if (running.size === 0) break;
+      await Promise.race(running.values());
+    }
+    await Promise.all(running.values());
+    for (const task of run.tasks) {
+      if (task.status !== "pending") continue;
+      if (controller.signal.aborted) this.endTask(task, "cancelled");
+      else this.endTask(task, "skipped", "Its dependencies never finished.");
+    }
+  }
+  /** Pending tasks that depend on a task that ended without `done` will never run. */
+  skipBlocked(run) {
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const task of run.tasks) {
+        if (task.status !== "pending") continue;
+        const blocker = task.dependsOn.map((dep) => this.taskById(run, dep)).find(
+          (dep) => dep && dep.status !== "done" && dep.status !== "pending" && dep.status !== "running"
+        );
+        if (!blocker) continue;
+        this.endTask(
+          task,
+          "skipped",
+          `Depends on ${blocker.id} (${blocker.title}), which ended ${blocker.status}.`
+        );
+        this.changed(run);
+        changed = true;
+      }
+    }
+  }
+  /** Never rejects: every outcome ends up on the task. */
+  async runTask(active, task) {
+    const { run, controller } = active;
+    const { workspace, runner } = this.options;
+    const signal = controller.signal;
+    task.status = "running";
+    task.startedAt = this.stamp();
+    this.changed(run);
+    try {
+      const ws = await this.git.run(
+        () => workspace.createTask(run.id, task.id, run.integrationBranch)
+      );
+      task.branch = ws.branch;
+      if (signal.aborted) throw signal.reason;
+      this.changed(run);
+      this.output(run.id, task.id, {
+        kind: "status",
+        text: `Starting ${task.agent} on ${ws.branch}`
+      });
+      const result = await runner.run({
+        agent: task.agent,
+        cwd: ws.path,
+        prompt: buildTaskPrompt({ objective: run.objective, task, tasks: run.tasks }),
+        mode: "edit",
+        signal,
+        timeoutMs: ORCHESTRATOR_LIMITS.taskTimeoutMs,
+        onOutput: (chunk) => this.output(run.id, task.id, chunk)
+      });
+      if (signal.aborted) throw signal.reason;
+      if (result.text.trim())
+        task.summary = clip3(result.text, ORCHESTRATOR_LIMITS.summaryMaxLength);
+      if (!result.ok) {
+        this.endTask(task, "failed", result.error ?? `${task.agent} did not finish the task.`);
+        return;
+      }
+      const files = await this.git.run(() => workspace.commitTask(ws, `davecode: ${task.title}`));
+      task.changedFiles = files;
+      if (files.length > 0) {
+        const merged = await this.git.run(
+          () => workspace.mergeIntoIntegration(
+            run.id,
+            ws.branch,
+            `davecode: merge ${task.id} ${task.title}`
+          )
+        );
+        if (!merged.ok) {
+          this.endTask(task, "conflict", merged.reason);
+          return;
+        }
+      }
+      this.endTask(task, "done");
+    } catch (err) {
+      if (signal.aborted || isAbortError(err)) this.endTask(task, "cancelled");
+      else this.endTask(task, "failed", errorText3(err));
+    } finally {
+      this.changed(run);
+    }
+  }
+  /** Final status and deterministic summary. */
+  finish(run, cancelled) {
+    for (const task of run.tasks) {
+      if (task.status === "pending" || task.status === "running") this.endTask(task, "cancelled");
+    }
+    const total = run.tasks.length;
+    const done = run.tasks.filter((t) => t.status === "done").length;
+    const notes = run.tasks.filter((t) => t.status !== "done").map((t) => describeOutcome(t));
+    const where = run.integrationBranch ?? "the integration branch";
+    if (cancelled) {
+      run.status = "cancelled";
+      run.summary = total === 0 ? "Cancelled while planning." : `Cancelled: ${done} of ${total} tasks had finished on ${where}.`;
+    } else if (done > 0) {
+      run.status = "done";
+      const tail2 = notes.length > 0 ? ` ${notes.join("; ")}.` : "";
+      run.summary = `${done} of ${total} tasks finished on ${where}.${tail2} Apply it to merge into ${run.baseBranch ?? "the base branch"}.`;
+    } else {
+      run.status = "failed";
+      run.error = "No task finished.";
+      run.summary = `None of the ${total} tasks finished. ${notes.join("; ")}.`;
+    }
+    this.changed(run);
+  }
+  endTask(task, status, error) {
+    if (task.status !== "pending" && task.status !== "running") return;
+    task.status = status;
+    if (error) task.error = clip3(error, ERROR_MAX_LENGTH);
+    if (task.startedAt) task.finishedAt = this.stamp();
+  }
+  // --- Helpers ---------------------------------------------------------------------------------
+  assertIdle() {
+    const current = [...this.active.values()].find((a) => isActive(a.run));
+    if (current || this.starting) {
+      throw new OrchestratorError(
+        "busy",
+        current ? `Run ${current.run.id} is still ${current.run.status}; cancel it or wait for it to end.` : "Another run is starting."
+      );
+    }
+  }
+  recoverInterrupted() {
+    const interrupted = this.runs.filter(isActive);
+    if (interrupted.length === 0) return;
+    const stamp = this.stamp();
+    for (const run of interrupted) {
+      for (const task of run.tasks) {
+        if (task.status === "running") {
+          task.status = "failed";
+          task.error = INTERRUPTED_ERROR;
+          task.finishedAt = stamp;
+        } else if (task.status === "pending") {
+          task.status = "cancelled";
+        }
+      }
+      run.status = "failed";
+      run.error = INTERRUPTED_ERROR;
+      run.updatedAt = stamp;
+      const { workspace } = this.options;
+      Promise.resolve().then(() => workspace.cleanup(run.id)).catch(() => void 0);
+    }
+    void this.store.save(this.runs);
+  }
+  find(id) {
+    return this.runs.find((run) => run.id === id);
+  }
+  taskById(run, id) {
+    return run.tasks.find((task) => task.id === id);
+  }
+  stamp() {
+    return this.now().toISOString();
+  }
+  /** Keeps the newest runs, never dropping an active one. */
+  trim() {
+    if (this.runs.length <= RUNS_KEPT) return;
+    const keep = new Set(this.runs.slice(0, RUNS_KEPT));
+    this.runs = this.runs.filter((run) => keep.has(run) || this.active.has(run.id));
+  }
+  /** Records a state change: bump `updatedAt`, persist, emit a snapshot. */
+  changed(run) {
+    run.updatedAt = this.stamp();
+    void this.store.save(this.runs);
+    this.options.events.emit({
+      type: "orchestrator.run",
+      run: structuredClone(run),
+      ts: this.now().getTime()
+    });
+  }
+  output(runId, taskId, chunk) {
+    const text = chunk.text.length > OUTPUT_MAX_LENGTH ? chunk.text.slice(0, OUTPUT_MAX_LENGTH) : chunk.text;
+    if (!text && chunk.kind !== "error") return;
+    this.options.events.emit({
+      type: "orchestrator.output",
+      runId,
+      taskId,
+      output: { kind: chunk.kind, text },
+      ts: this.now().getTime()
+    });
+  }
+};
+function describeOutcome(task) {
+  const reason = task.error ? `: ${clip3(task.error, 120)}` : "";
+  switch (task.status) {
+    case "conflict":
+      return `${task.id} conflicts with the integration branch${reason}`;
+    case "failed":
+      return `${task.id} failed${reason}`;
+    case "skipped":
+      return `${task.id} was skipped${reason}`;
+    case "cancelled":
+      return `${task.id} was cancelled`;
+    default:
+      return `${task.id} is ${task.status}`;
+  }
+}
+var SAFE_ID2 = /^[A-Za-z0-9_-]+$/;
+var INTEGRATION_DIR = "integration";
+var BRAIN_DIR2 = ".davecode";
+var FALLBACK_IDENTITY = ["-c", "user.name=DaveCode", "-c", "user.email=davecode@localhost"];
+function assertId(kind, value) {
+  if (!SAFE_ID2.test(value)) {
+    throw new GitError(`Invalid ${kind}: ${JSON.stringify(value)}`, [], null, "");
+  }
+  return value;
+}
+function lines(out) {
+  return out.split("\n").map((l) => l.replace(/\r$/, "")).filter((l) => l.trim().length > 0);
+}
+function nulList(out) {
+  return out.split("\0").filter((f) => f.length > 0);
+}
+function errMessage(err) {
+  const raw = err instanceof Error ? err.message : String(err);
+  const text = raw.replace(/\s+/g, " ").trim();
+  return text.length <= 300 ? text : `${text.slice(0, 299)}\u2026`;
+}
+function realPath2(p) {
+  try {
+    return realpathSync2.native(p);
+  } catch {
+    return path9.resolve(p);
+  }
+}
+function samePath(a, b) {
+  const na = realPath2(a);
+  const nb = realPath2(b);
+  return process.platform === "win32" ? na.toLowerCase() === nb.toLowerCase() : na === nb;
+}
+function isInside2(child, parent) {
+  const rel = path9.relative(realPath2(parent), realPath2(child));
+  return rel === "" || !rel.startsWith("..") && !path9.isAbsolute(rel);
+}
+function createGitWorkspace(options) {
+  const projectDir = path9.resolve(options.projectDir);
+  const worktreesDir = path9.resolve(options.worktreesDir);
+  const gitAt = (cwd) => new Git(cwd, { env: options.env });
+  const repo = gitAt(projectDir);
+  const runDir = (runId) => path9.join(worktreesDir, assertId("run id", runId));
+  const integrationPath = (runId) => path9.join(runDir(runId), INTEGRATION_DIR);
+  const integrationBranch = (runId) => `davecode/run-${assertId("run id", runId)}`;
+  const taskBases = /* @__PURE__ */ new Map();
+  let queue = Promise.resolve();
+  const serial = (fn2) => {
+    const next = queue.then(fn2, fn2);
+    queue = next.catch(() => void 0);
+    return next;
+  };
+  let hasIdentity = false;
+  async function identityArgs(g) {
+    if (hasIdentity) return [];
+    try {
+      await g.run(["var", "GIT_AUTHOR_IDENT"]);
+      await g.run(["var", "GIT_COMMITTER_IDENT"]);
+      hasIdentity = true;
+      return [];
+    } catch {
+      return FALLBACK_IDENTITY;
+    }
+  }
+  async function removeWorktree(target) {
+    try {
+      await repo.run(["worktree", "remove", "--force", target]);
+    } catch {
+    }
+    if (existsSync5(target)) {
+      rmSync5(target, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+    }
+    try {
+      await repo.run(["worktree", "prune"]);
+    } catch {
+    }
+  }
+  async function addWorktree(target, branch, base) {
+    const args = ["worktree", "add", "-B", assertSafeRef(branch), target, assertSafeRef(base)];
+    try {
+      await repo.run(args);
+    } catch {
+      await removeWorktree(target);
+      await repo.run(args);
+    }
+  }
+  async function merge(g, branch, message, noVerify) {
+    const args = [...await identityArgs(g), "merge", "--no-ff", "--no-edit", "-m", message];
+    if (noVerify) args.push("--no-verify");
+    args.push(assertSafeRef(branch));
+    try {
+      await g.run(args);
+      return { ok: true };
+    } catch (err) {
+      let conflicts = [];
+      try {
+        conflicts = nulList(await g.run(["diff", "--name-only", "-z", "--diff-filter=U"]));
+      } catch {
+      }
+      await g.abortMerge();
+      const reason = conflicts.length > 0 ? `Conflicts in ${conflicts.join(", ")}` : `Merge failed: ${errMessage(err)}`;
+      return { ok: false, reason };
+    }
+  }
+  return {
+    async check() {
+      if (!await repo.isRepo()) {
+        return {
+          ok: false,
+          reason: "This folder is not a git repository. Run `git init` and commit once to orchestrate agents."
+        };
+      }
+      let commit;
+      try {
+        commit = (await repo.run(["rev-parse", "--verify", "--quiet", "HEAD^{commit}"])).trim();
+      } catch {
+        return {
+          ok: false,
+          reason: "This repository has no commits yet. Commit once to orchestrate agents."
+        };
+      }
+      let branch;
+      try {
+        branch = (await repo.run(["symbolic-ref", "--quiet", "--short", "HEAD"])).trim();
+      } catch {
+        return {
+          ok: false,
+          reason: "HEAD is detached. Check out a branch to orchestrate agents."
+        };
+      }
+      return { ok: true, branch, commit };
+    },
+    createIntegration(runId, baseCommit) {
+      return serial(async () => {
+        const branch = integrationBranch(runId);
+        await addWorktree(integrationPath(runId), branch, baseCommit);
+        return branch;
+      });
+    },
+    createTask(runId, taskId, base) {
+      return serial(async () => {
+        assertId("task id", taskId);
+        if (taskId === INTEGRATION_DIR) {
+          throw new GitError(`Invalid task id: ${JSON.stringify(taskId)}`, [], null, "");
+        }
+        const branch = `${integrationBranch(runId)}-${taskId}`;
+        const target = path9.join(runDir(runId), taskId);
+        const baseCommit = (await repo.run(["rev-parse", "--verify", "--quiet", `${assertSafeRef(base)}^{commit}`])).trim();
+        await addWorktree(target, branch, baseCommit);
+        taskBases.set(path9.resolve(target), baseCommit);
+        return { path: target, branch };
+      });
+    },
+    commitTask(workspace, message) {
+      return serial(async () => {
+        const g = gitAt(workspace.path);
+        await g.run(["add", "-A"]);
+        await g.run(["reset", "-q", "--", BRAIN_DIR2]);
+        const committed = await g.hasStagedChanges();
+        if (committed) {
+          await g.run([
+            ...await identityArgs(g),
+            "commit",
+            "--quiet",
+            "--no-verify",
+            "-m",
+            message
+          ]);
+        }
+        const base = taskBases.get(path9.resolve(workspace.path));
+        if (base) return nulList(await g.run(["diff", "--name-only", "-z", base, "HEAD"]));
+        if (!committed) return [];
+        return nulList(await g.run(["diff", "--name-only", "-z", "HEAD~1", "HEAD"]));
+      });
+    },
+    mergeIntoIntegration(runId, branch, message) {
+      return serial(async () => {
+        const target = integrationPath(runId);
+        if (!existsSync5(target)) {
+          return { ok: false, reason: `The integration worktree for run ${runId} is missing` };
+        }
+        return merge(gitAt(target), branch, message, true);
+      });
+    },
+    apply(runId, baseBranch) {
+      return serial(async () => {
+        const branch = integrationBranch(runId);
+        if (!await repo.branchExists(branch)) {
+          return { ok: false, reason: `Branch ${branch} does not exist` };
+        }
+        let current;
+        try {
+          current = (await repo.run(["symbolic-ref", "--quiet", "--short", "HEAD"])).trim();
+        } catch {
+          current = "a detached HEAD";
+        }
+        if (current !== baseBranch) {
+          return {
+            ok: false,
+            reason: `Check out ${baseBranch} first: the run started there (you are on ${current}).`
+          };
+        }
+        const dirty = lines(
+          await repo.run(["status", "--porcelain", "--untracked-files=no"])
+        ).filter((l) => {
+          const file = l.slice(3).replace(/^"|"$/g, "");
+          return !(file === BRAIN_DIR2 || file.startsWith(`${BRAIN_DIR2}/`));
+        });
+        if (dirty.length > 0) {
+          return { ok: false, reason: "Commit or stash your changes first." };
+        }
+        return merge(repo, branch, `davecode: apply run ${runId}`, false);
+      });
+    },
+    cleanup(runId) {
+      return serial(async () => {
+        let dir;
+        try {
+          dir = runDir(runId);
+        } catch {
+          return;
+        }
+        try {
+          const listed = lines(await repo.run(["worktree", "list", "--porcelain"])).filter((l) => l.startsWith("worktree ")).map((l) => l.slice("worktree ".length)).filter((p) => isInside2(p, dir) && !samePath(p, projectDir));
+          for (const target of listed) {
+            try {
+              await repo.run(["worktree", "remove", "--force", target]);
+            } catch {
+            }
+            taskBases.delete(path9.resolve(target));
+          }
+        } catch {
+        }
+        try {
+          rmSync5(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+        } catch {
+        }
+        try {
+          await repo.run(["worktree", "prune"]);
+        } catch {
+        }
+      });
+    }
+  };
+}
 
 export {
   ProviderError,
@@ -9889,6 +11426,13 @@ export {
   goalSchema,
   isGoalId,
   GoalStore,
-  createGoalService
+  createGoalService,
+  ORCHESTRATOR_AGENTS,
+  ORCHESTRATOR_LIMITS,
+  startRunSchema,
+  OrchestratorError,
+  createCliAgentRunner,
+  createOrchestratorService,
+  createGitWorkspace
 };
-//# sourceMappingURL=chunk-ING5HCIO.js.map
+//# sourceMappingURL=chunk-2XGDILCW.js.map