@dmrlzz/davecode 0.6.0 → 0.7.0

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

@@ -120,21 +120,37 @@ import { mkdirSync as mkdirSync7, readFileSync as readFileSync3, rmSync as rmSyn
 import { dirname as dirname6, join as join6 } from "path";
 import { z as z9 } from "zod";
 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 { execFile as execFile2 } from "child_process";
+import { createHash as createHash3, randomBytes as randomBytes9 } from "crypto";
+import {
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync8,
+  readdirSync,
+  readFileSync as readFileSync4,
+  realpathSync as realpathSync2,
+  rmSync as rmSync5,
+  statSync as statSync4,
+  writeFileSync as writeFileSync4
+} from "fs";
+import path9 from "path";
+import { z as z13 } 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 z11 } from "zod";
+import { z as z12 } from "zod";
 import { z as z14 } from "zod";
-import { existsSync as existsSync5, realpathSync as realpathSync2, rmSync as rmSync5 } from "fs";
-import path9 from "path";
+import { readdir as readdir3 } from "fs/promises";
+import { join as join7, relative as relative2 } from "path";
+import { z as z15 } from "zod";
+import { randomBytes as randomBytes10 } from "crypto";
+import { z as z16 } from "zod";
+import { createHash as createHash4 } from "crypto";
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join8, resolve as resolve5 } from "path";
+import { z as z17 } from "zod";
+import { existsSync as existsSync6, realpathSync as realpathSync3, rmSync as rmSync6 } from "fs";
+import path10 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) => {
@@ -587,14 +603,14 @@ function projectPaths(root) {
 }
 var sleep = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
 var RETRYABLE_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]);
-async function atomicWriteFile(path10, content) {
-  await mkdir(dirname(path10), { recursive: true });
-  const tmp = `${path10}.${process.pid}.${randomBytes2(4).toString("hex")}.tmp`;
+async function atomicWriteFile(path11, content) {
+  await mkdir(dirname(path11), { recursive: true });
+  const tmp = `${path11}.${process.pid}.${randomBytes2(4).toString("hex")}.tmp`;
   try {
     await writeFile(tmp, content, "utf8");
     for (let attempt = 0; ; attempt++) {
       try {
-        await rename(tmp, path10);
+        await rename(tmp, path11);
         return;
       } catch (err) {
         const code = err.code;
@@ -607,9 +623,9 @@ async function atomicWriteFile(path10, content) {
     throw err;
   }
 }
-async function readFileIfExists(path10) {
+async function readFileIfExists(path11) {
   try {
-    return await readFile(path10, "utf8");
+    return await readFile(path11, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return void 0;
     throw err;
@@ -1041,9 +1057,9 @@ var LockTimeoutError = class extends Error {
 };
 var TRANSIENT_OPEN_ERRORS = ["EPERM", "EACCES", "EBUSY"];
 var sleep2 = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
-async function readLockInfo(path10) {
+async function readLockInfo(path11) {
   try {
-    const parsed = JSON.parse(await readFile2(path10, "utf8"));
+    const parsed = JSON.parse(await readFile2(path11, "utf8"));
     if (typeof parsed === "object" && parsed !== null && typeof parsed.ts === "number" && typeof parsed.pid === "number") {
       return parsed;
     }
@@ -1051,11 +1067,11 @@ async function readLockInfo(path10) {
   }
   return void 0;
 }
-async function lockAge(path10) {
-  const info = await readLockInfo(path10);
+async function lockAge(path11) {
+  const info = await readLockInfo(path11);
   if (info) return Date.now() - info.ts;
   try {
-    return Date.now() - (await stat2(path10)).mtimeMs;
+    return Date.now() - (await stat2(path11)).mtimeMs;
   } catch {
     return void 0;
   }
@@ -1102,9 +1118,9 @@ async function withFileLock(lockPath, fn2, opts = {}) {
     }
   }
 }
-async function exists(path10) {
+async function exists(path11) {
   try {
-    await access(path10);
+    await access(path11);
     return true;
   } catch {
     return false;
@@ -1163,8 +1179,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(path10) {
-    super(`Missing project brain file: ${path10} (run ProjectBrain.init first)`);
+  constructor(path11) {
+    super(`Missing project brain file: ${path11} (run ProjectBrain.init first)`);
     this.name = "MissingBrainError";
   }
 };
@@ -1202,8 +1218,8 @@ var ProjectBrain = class _ProjectBrain {
       [brain.paths.architecture, architectureTemplate(name)],
       [brain.paths.taskGraph, serializeGraph(taskGraphTemplate())]
     ];
-    for (const [path10, content] of files) {
-      if (!await exists(path10)) await atomicWriteFile(path10, content);
+    for (const [path11, content] of files) {
+      if (!await exists(path11)) await atomicWriteFile(path11, content);
     }
     return brain;
   }
@@ -1315,10 +1331,10 @@ ${line}` : line);
     this.events?.emit({ type: "task.updated", task });
     return task;
   }
-  async readText(path10) {
-    const content = await readFileIfExists(path10);
+  async readText(path11) {
+    const content = await readFileIfExists(path11);
     if (content === void 0) {
-      throw new MissingBrainError(path10);
+      throw new MissingBrainError(path11);
     }
     return content;
   }
@@ -1532,14 +1548,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 path10 = prefix ? `${prefix}.${key}` : key;
+      const path11 = prefix ? `${prefix}.${key}` : key;
       if (rule === true) {
         out[key] = v;
       } else if (rule && isPlainObject(v)) {
-        const inner = walk(v, rule, path10);
+        const inner = walk(v, rule, path11);
         if (Object.keys(inner).length > 0) out[key] = inner;
       } else {
-        dropped.push(path10);
+        dropped.push(path11);
       }
     }
     return out;
@@ -1564,21 +1580,21 @@ function deepMerge(base, override) {
   }
   return out;
 }
-function readLayer(path10, project) {
+function readLayer(path11, project) {
   let raw;
   try {
-    raw = readFileSync(path10, "utf8");
+    raw = readFileSync(path11, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return void 0;
-    throw new ConfigError(path10, `cannot read file: ${err.message}`, { cause: err });
+    throw new ConfigError(path11, `cannot read file: ${err.message}`, { cause: err });
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
-    throw new ConfigError(path10, `malformed JSON: ${err.message}`, { cause: err });
+    throw new ConfigError(path11, `malformed JSON: ${err.message}`, { cause: err });
   }
-  if (!isPlainObject(parsed)) throw new ConfigError(path10, "expected a JSON object");
+  if (!isPlainObject(parsed)) throw new ConfigError(path11, "expected a JSON object");
   let layer = parsed;
   if (project) {
     const { allowed, dropped } = filterProjectLayer(parsed);
@@ -1586,7 +1602,7 @@ function readLayer(path10, project) {
     layer = allowed;
   }
   const result = configSchema.safeParse(layer);
-  if (!result.success) throw new ConfigError(path10, z4.prettifyError(result.error));
+  if (!result.success) throw new ConfigError(path11, z4.prettifyError(result.error));
   return layer;
 }
 var TRUE_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
@@ -1665,19 +1681,19 @@ function loadConfig(options = {}) {
 }
 var isPlainObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 async function writeGlobalRouting(home, update, lock = {}) {
-  const path10 = globalPaths(home).config;
+  const path11 = globalPaths(home).config;
   return withFileLock(
-    `${path10}.lock`,
+    `${path11}.lock`,
     async () => {
       let current = {};
       try {
-        const parsed = JSON.parse(await readFile3(path10, "utf8"));
-        if (!isPlainObject2(parsed)) throw new ConfigError(path10, "expected a JSON object");
+        const parsed = JSON.parse(await readFile3(path11, "utf8"));
+        if (!isPlainObject2(parsed)) throw new ConfigError(path11, "expected a JSON object");
         current = parsed;
       } catch (err) {
         if (err instanceof ConfigError) throw err;
         if (!isNodeError(err, "ENOENT")) {
-          throw new ConfigError(path10, `cannot update this file: ${err.message}`, {
+          throw new ConfigError(path11, `cannot update this file: ${err.message}`, {
             cause: err
           });
         }
@@ -1692,11 +1708,11 @@ async function writeGlobalRouting(home, update, lock = {}) {
         }
       };
       const checked = configSchema.safeParse(next);
-      if (!checked.success) throw new ConfigError(path10, z5.prettifyError(checked.error));
-      await atomicWriteFile(path10, `${JSON.stringify(next, null, 2)}
+      if (!checked.success) throw new ConfigError(path11, z5.prettifyError(checked.error));
+      await atomicWriteFile(path11, `${JSON.stringify(next, null, 2)}
 `);
       return {
-        path: path10,
+        path: path11,
         routes: checked.data.routing.routes,
         defaultRoute: checked.data.routing.defaultRoute
       };
@@ -1784,8 +1800,8 @@ function makeUsage(prompt, completion) {
 function stripProviderPrefix(model, provider) {
   return model.startsWith(`${provider}/`) ? model.slice(provider.length + 1) : model;
 }
-function joinUrl(base, path10) {
-  return `${base.replace(/\/+$/, "")}/${path10.replace(/^\/+/, "")}`;
+function joinUrl(base, path11) {
+  return `${base.replace(/\/+$/, "")}/${path11.replace(/^\/+/, "")}`;
 }
 function configString(config, key) {
   const value = config[key];
@@ -2002,7 +2018,7 @@ function fraction(d) {
 }
 function limitsFromHeaders(headers, now = Date.now()) {
   const pick = (a, b) => a.remaining !== void 0 ? a : b;
-  const tokens = pick(
+  const tokens2 = pick(
     pick(
       dimension(
         headers,
@@ -2049,16 +2065,16 @@ function limitsFromHeaders(headers, now = Date.now()) {
       now
     )
   );
-  if (tokens.remaining === void 0 && requests.remaining === void 0) return void 0;
+  if (tokens2.remaining === void 0 && requests.remaining === void 0) return void 0;
   const out = {};
-  if (tokens.remaining !== void 0) out.tokensRemaining = tokens.remaining;
-  if (tokens.limit !== void 0) out.tokensLimit = tokens.limit;
+  if (tokens2.remaining !== void 0) out.tokensRemaining = tokens2.remaining;
+  if (tokens2.limit !== void 0) out.tokensLimit = tokens2.limit;
   if (requests.remaining !== void 0) out.requestsRemaining = requests.remaining;
   if (requests.limit !== void 0) out.requestsLimit = requests.limit;
-  const tighter = (fraction(tokens) ?? 1) <= (fraction(requests) ?? 1) ? tokens : requests;
-  const resetAt = tighter.resetAt ?? tokens.resetAt ?? requests.resetAt;
+  const tighter = (fraction(tokens2) ?? 1) <= (fraction(requests) ?? 1) ? tokens2 : requests;
+  const resetAt = tighter.resetAt ?? tokens2.resetAt ?? requests.resetAt;
   if (resetAt !== void 0) out.resetAt = resetAt;
-  if (tokens.remaining === 0 || requests.remaining === 0) out.exhausted = true;
+  if (tokens2.remaining === 0 || requests.remaining === 0) out.exhausted = true;
   return out;
 }
 function reportedFraction(limits) {
@@ -2602,8 +2618,8 @@ var SHELL_SAFE = /^[\w.:=@+\-/\\[\]]+$/;
 function isShellSafeArg(arg) {
   return SHELL_SAFE.test(arg);
 }
-function quoteCommand(path10) {
-  return isShellSafeArg(path10) ? path10 : `"${path10}"`;
+function quoteCommand(path11) {
+  return isShellSafeArg(path11) ? path11 : `"${path11}"`;
 }
 function killTree(child) {
   if (child.pid === void 0 || child.exitCode !== null) return;
@@ -4047,7 +4063,7 @@ var SUBSCRIPTION_PROVIDER_KINDS = [
   "antigravity-cli",
   "gemini-web"
 ];
-var VERSION = "0.6.0";
+var VERSION = "0.7.0";
 var QUOTA_WINDOWS = ["1m", "5h", "24h"];
 var WINDOW_MS = {
   "1m": 6e4,
@@ -4059,19 +4075,19 @@ var WINDOW_COUNT = QUOTA_WINDOWS.length;
 function limitsFor(window, limits) {
   const pick = (v) => v !== void 0 && v > 0 ? v : void 0;
   const out = {};
-  let tokens;
+  let tokens2;
   let requests;
   if (window === "1m") {
-    tokens = pick(limits.tpm);
+    tokens2 = pick(limits.tpm);
     requests = pick(limits.rpm);
   } else if (window === "5h") {
-    tokens = pick(limits.tokens5h);
+    tokens2 = pick(limits.tokens5h);
     requests = pick(limits.requests5h);
   } else {
-    tokens = pick(limits.tokensDaily);
+    tokens2 = pick(limits.tokensDaily);
     requests = pick(limits.requestsDaily);
   }
-  if (tokens !== void 0) out.tokenLimit = tokens;
+  if (tokens2 !== void 0) out.tokenLimit = tokens2;
   if (requests !== void 0) out.requestLimit = requests;
   return out;
 }
@@ -4083,26 +4099,26 @@ var AccountSeries = class {
   heads = new Array(WINDOW_COUNT).fill(0);
   tokenSums = new Array(WINDOW_COUNT).fill(0);
   requestSums = new Array(WINDOW_COUNT).fill(0);
-  add(ts, tokens, requests) {
+  add(ts, tokens2, requests) {
     const last = this.slotTs.length - 1;
     let slot = Math.floor(ts / SLOT_MS) * SLOT_MS;
     if (last >= 0 && slot < this.slotTs[last]) slot = this.slotTs[last];
     if (last >= 0 && this.slotTs[last] === slot) {
-      this.slotTokens[last] += tokens;
+      this.slotTokens[last] += tokens2;
       this.slotRequests[last] += requests;
       for (let w = 0; w < WINDOW_COUNT; w++) {
         if (this.heads[w] <= last) {
-          this.tokenSums[w] += tokens;
+          this.tokenSums[w] += tokens2;
           this.requestSums[w] += requests;
         }
       }
       return;
     }
     this.slotTs.push(slot);
-    this.slotTokens.push(tokens);
+    this.slotTokens.push(tokens2);
     this.slotRequests.push(requests);
     for (let w = 0; w < WINDOW_COUNT; w++) {
-      this.tokenSums[w] += tokens;
+      this.tokenSums[w] += tokens2;
       this.requestSums[w] += requests;
     }
   }
@@ -4152,13 +4168,13 @@ var QuotaEngine = class {
   constructor(options = {}) {
     this.clock = options.clock ?? Date.now;
   }
-  record(accountId, tokens, options = {}) {
+  record(accountId, tokens2, options = {}) {
     let series = this.series.get(accountId);
     if (!series) {
       series = new AccountSeries();
       this.series.set(accountId, series);
     }
-    series.add(options.ts ?? this.clock(), Math.max(0, tokens), Math.max(0, options.requests ?? 1));
+    series.add(options.ts ?? this.clock(), Math.max(0, tokens2), Math.max(0, options.requests ?? 1));
     series.advance(this.clock());
   }
   totals(accountId) {
@@ -4173,11 +4189,11 @@ var QuotaEngine = class {
     const totals = this.totals(account.id);
     const windows = {};
     QUOTA_WINDOWS.forEach((window, i) => {
-      const { tokens, requests } = totals[i];
+      const { tokens: tokens2, requests } = totals[i];
       const limits = limitsFor(window, account.limits);
-      const usage = { window, tokens, requests, utilization: 0, ...limits };
+      const usage = { window, tokens: tokens2, requests, utilization: 0, ...limits };
       usage.utilization = Math.max(
-        limits.tokenLimit ? tokens / limits.tokenLimit : 0,
+        limits.tokenLimit ? tokens2 / limits.tokenLimit : 0,
         limits.requestLimit ? requests / limits.requestLimit : 0
       );
       windows[window] = usage;
@@ -4193,9 +4209,9 @@ var QuotaEngine = class {
   wouldExceed(account, estimatedTokens) {
     const totals = this.totals(account.id);
     return QUOTA_WINDOWS.some((window, i) => {
-      const { tokens, requests } = totals[i];
+      const { tokens: tokens2, requests } = totals[i];
       const { tokenLimit, requestLimit } = limitsFor(window, account.limits);
-      if (tokenLimit !== void 0 && tokens + estimatedTokens > tokenLimit) return true;
+      if (tokenLimit !== void 0 && tokens2 + estimatedTokens > tokenLimit) return true;
       if (requestLimit !== void 0 && requests + 1 > requestLimit) return true;
       return false;
     });
@@ -5193,19 +5209,19 @@ var Router = class {
     });
   }
   /** The caller aborted: record the attempt as cancelled without touching cooldowns. */
-  onCancelled(candidate, requestId, startedAt, tokens = { prompt: 0, completion: 0 }) {
+  onCancelled(candidate, requestId, startedAt, tokens2 = { prompt: 0, completion: 0 }) {
     const latencyMs = Math.max(0, this.clock() - startedAt);
     this.breaker.onCancel(candidate.account.id);
     this.recordUsage(
       candidate,
       requestId,
       "cancelled",
-      tokens.prompt,
-      tokens.completion,
+      tokens2.prompt,
+      tokens2.completion,
       latencyMs
     );
   }
-  onFailure(candidate, requestId, error, startedAt, tokens = { prompt: 0, completion: 0 }) {
+  onFailure(candidate, requestId, error, startedAt, tokens2 = { prompt: 0, completion: 0 }) {
     const { account } = candidate;
     const latencyMs = Math.max(0, this.clock() - startedAt);
     const rateLimited = error.kind === "rate_limit" || error.kind === "quota_exhausted";
@@ -5213,8 +5229,8 @@ var Router = class {
       candidate,
       requestId,
       rateLimited ? "rate_limited" : "error",
-      tokens.prompt,
-      tokens.completion,
+      tokens2.prompt,
+      tokens2.completion,
       latencyMs,
       error.kind
     );
@@ -5383,7 +5399,7 @@ var Router = class {
       if (chunk.usage) upstreamUsage = chunk.usage;
       for (const choice of chunk.choices) text += messageText(choice.delta);
     };
-    const tokens = () => {
+    const tokens2 = () => {
       const has = upstreamUsage && (upstreamUsage.prompt_tokens > 0 || upstreamUsage.completion_tokens > 0);
       return has && upstreamUsage ? { prompt: upstreamUsage.prompt_tokens, completion: upstreamUsage.completion_tokens } : { prompt: estimate, completion: countTextTokens(text) };
     };
@@ -5405,9 +5421,9 @@ var Router = class {
       failed = true;
       const error = toProviderError2(err, candidate.account);
       if (signal?.aborted) {
-        this.onCancelled(candidate, meta.requestId, startedAt, tokens());
+        this.onCancelled(candidate, meta.requestId, startedAt, tokens2());
       } else {
-        this.onFailure(candidate, meta.requestId, error, startedAt, tokens());
+        this.onFailure(candidate, meta.requestId, error, startedAt, tokens2());
       }
       throw error;
     } finally {
@@ -5418,7 +5434,7 @@ var Router = class {
         }
       }
       if (!failed) {
-        const { prompt, completion } = tokens();
+        const { prompt, completion } = tokens2();
         this.onSuccess(candidate, meta.requestId, prompt, completion, startedAt);
       }
     }
@@ -5695,9 +5711,9 @@ function migrate(db, migrations = MIGRATIONS) {
   }
   return version;
 }
-function openDatabase(path10, options = {}) {
-  if (path10 !== ":memory:") mkdirSync5(dirname5(path10), { recursive: true });
-  const db = new BetterSqlite3(path10);
+function openDatabase(path11, options = {}) {
+  if (path11 !== ":memory:") mkdirSync5(dirname5(path11), { recursive: true });
+  const db = new BetterSqlite3(path11);
   try {
     db.pragma("journal_mode = WAL");
     db.pragma("foreign_keys = ON");
@@ -6899,7 +6915,7 @@ ${repairPrompt(runOpts.cycle, runOpts.failureReport)}`;
       }
       let resultText;
       let isError = false;
-      let tokens = 0;
+      let tokens2 = 0;
       let turns = 0;
       try {
         for await (const raw of cli.events) {
@@ -6919,7 +6935,7 @@ ${repairPrompt(runOpts.cycle, runOpts.failureReport)}`;
             resultText = asString(raw.result) ?? "";
             isError = raw.is_error === true || (asString(raw.subtype) ?? "success") !== "success";
             const usage = isRecord(raw.usage) ? raw.usage : {};
-            tokens = (asNumber(usage.input_tokens) ?? 0) + (asNumber(usage.output_tokens) ?? 0) + (asNumber(usage.cache_creation_input_tokens) ?? 0);
+            tokens2 = (asNumber(usage.input_tokens) ?? 0) + (asNumber(usage.output_tokens) ?? 0) + (asNumber(usage.cache_creation_input_tokens) ?? 0);
           }
         }
       } catch (err) {
@@ -6938,7 +6954,7 @@ ${repairPrompt(runOpts.cycle, runOpts.failureReport)}`;
           `Claude Code CLI timed out after ${opts.timeoutMs ?? 18e5} ms`
         );
       }
-      totalTokens += tokens;
+      totalTokens += tokens2;
       if (exit.code !== 0 || isError || resultText === void 0) {
         const detail = redact(
           (isError && resultText ? resultText : exit.stderr || resultText || "").trim()
@@ -6951,7 +6967,7 @@ ${repairPrompt(runOpts.cycle, runOpts.failureReport)}`;
         summary: resultText.trim() || "Implemented by Claude Code.",
         stopReason: "completed",
         iterations: Math.max(1, turns),
-        tokens,
+        tokens: tokens2,
         totalTokens,
         changedFiles: []
       };
@@ -8302,8 +8318,8 @@ var AccountClient = class {
     return url.toString();
   }
   /** A page of the hosted service, such as `/login/done`. */
-  pageUrl(path10) {
-    return `${this.service.url}${path10}`;
+  pageUrl(path11) {
+    return `${this.service.url}${path11}`;
   }
   /** Browser URL that starts Google or GitHub sign-in and returns to `redirectTo` with `?code=`. */
   authorizeUrl(provider, redirectTo, challenge) {
@@ -8356,13 +8372,13 @@ var AccountClient = class {
       signal: AbortSignal.timeout(1e4)
     }).catch(() => void 0);
   }
-  async session(path10, body) {
-    return toSession(await this.post(path10, body), this.now());
+  async session(path11, body) {
+    return toSession(await this.post(path11, body), this.now());
   }
-  async post(path10, body) {
+  async post(path11, body) {
     let response;
     try {
-      response = await this.fetch(`${this.service.url}/auth/v1/${path10}`, {
+      response = await this.fetch(`${this.service.url}/auth/v1/${path11}`, {
         method: "POST",
         headers: { apikey: this.service.publishableKey, "Content-Type": "application/json" },
         body: JSON.stringify(body),
@@ -8582,16 +8598,16 @@ var AccountStore = class {
    * refresh goes ahead without it (the service tolerates two refreshes racing).
    */
   async lock() {
-    const path10 = `${this.path}.lock`;
+    const path11 = `${this.path}.lock`;
     const owner = `${process.pid}:${randomBytes8(8).toString("hex")}`;
-    mkdirSync7(dirname6(path10), { recursive: true });
+    mkdirSync7(dirname6(path11), { recursive: true });
     const deadline = Date.now() + LOCK_WAIT_MS;
     for (; ; ) {
       try {
-        writeFileSync3(path10, owner, { flag: "wx", mode: 384 });
+        writeFileSync3(path11, owner, { flag: "wx", mode: 384 });
         return () => {
           try {
-            if (readFileSync3(path10, "utf8") === owner) rmSync3(path10, { force: true });
+            if (readFileSync3(path11, "utf8") === owner) rmSync3(path11, { force: true });
           } catch {
           }
         };
@@ -8600,7 +8616,7 @@ var AccountStore = class {
           return () => void 0;
       }
       try {
-        if (Date.now() - statSync2(path10).mtimeMs > LOCK_STALE_MS) rmSync3(path10, { force: true });
+        if (Date.now() - statSync2(path11).mtimeMs > LOCK_STALE_MS) rmSync3(path11, { force: true });
       } catch {
       }
       if (Date.now() >= deadline) return () => void 0;
@@ -8699,1548 +8715,2339 @@ function brandLogo(unicode = true) {
     (line) => line.replaceAll("\u2588", "#").replaceAll("\u2580", '"').replaceAll("\u2584", ".")
   );
 }
-var DEFAULT_ROLES = [
-  {
-    id: "planner",
-    description: "Breaks the objective into a plan, defines milestones and success criteria.",
-    kind: "artifact"
-  },
-  {
-    id: "researcher",
-    description: "Analyses markets, users, competitors and options from its own knowledge and the workspace; cannot browse the web.",
-    kind: "artifact"
-  },
-  {
-    id: "implementer",
-    description: "Writes and changes code in the repository (handed to the autonomous runner).",
-    kind: "code"
+var CHANGES_LIMITS = {
+  /** Most isolated workspaces per project. */
+  maxWorkspaces: 12,
+  labelMaxLength: 60,
+  messageMaxLength: 5e3,
+  titleMaxLength: 200,
+  bodyMaxLength: 2e4,
+  /** Largest patch returned by `diff` (characters); longer patches are cut and flagged. */
+  diffMaxLength: 1e6,
+  /** Largest untracked file rendered as a patch (bytes); bigger ones are listed as binary. */
+  untrackedMaxBytes: 512 * 1024,
+  /** Largest patch handed to an agent to write the commit message (characters). */
+  suggestDiffMaxLength: 4e4,
+  /** Hard timeout for an agent writing the commit message. */
+  suggestTimeoutMs: 3 * 6e4
+};
+var MAIN_WORKSPACE_ID = "main";
+var WORKSPACE_ID_PATTERN = /^[a-z0-9]{4,24}$/;
+var PANE_BRANCH_PREFIX = "davecode/pane-";
+var workspaceIdSchema = z10.string().refine((id) => id === MAIN_WORKSPACE_ID || WORKSPACE_ID_PATTERN.test(id), "invalid workspace");
+var safeRef = z10.string().regex(/^(?!.*\.\.)(?!.*\/\/)(?!\/)(?!.*\/$)(?!.*\.lock$)(?!-)[A-Za-z0-9._/-]{1,200}$/);
+var createWorkspaceSchema = z10.object({
+  label: z10.string().trim().min(1).max(CHANGES_LIMITS.labelMaxLength).optional()
+});
+var suggestSchema = z10.object({
+  /** Agent that writes the text; without one, DaveCode derives it from the file list. */
+  agent: z10.enum(["claude", "codex", "agy"]).optional()
+});
+var shipSchema = z10.object({
+  message: z10.string().trim().min(1).max(CHANGES_LIMITS.messageMaxLength).optional(),
+  push: z10.boolean().default(false),
+  pr: z10.object({
+    title: z10.string().trim().min(1).max(CHANGES_LIMITS.titleMaxLength),
+    body: z10.string().max(CHANGES_LIMITS.bodyMaxLength).default(""),
+    draft: z10.boolean().default(false),
+    /** Default: `baseBranch` for isolated workspaces, the remote's default branch otherwise. */
+    base: safeRef.optional()
+  }).optional()
+});
+var mergeSchema = z10.object({
+  /** Commits uncommitted work in the isolated workspace with this message before merging. */
+  message: z10.string().trim().min(1).max(CHANGES_LIMITS.messageMaxLength).optional()
+});
+var removeSchema = z10.object({
+  /** Also delete the workspace's branch. By default it stays, so no work is lost. */
+  deleteBranch: z10.boolean().default(false)
+});
+var ChangesError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ChangesError";
+  }
+  code;
+};
+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 = z11.object({
+  objective: z11.string().trim().min(1).max(ORCHESTRATOR_LIMITS.objectiveMaxLength),
+  /** Defaults to every available agent. */
+  agents: z11.array(z11.enum(ORCHESTRATOR_AGENTS)).min(1).max(3).optional(),
+  maxTasks: z11.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: z11.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"
   },
-  {
-    id: "reviewer",
-    description: "Critically reviews other outputs for gaps, risks and quality.",
-    kind: "artifact"
+  codex: {
+    label: "Codex",
+    binary: "codex",
+    provider: "codex-cli",
+    signIn: "run `codex login` in a terminal"
   },
-  {
-    id: "writer",
-    description: "Writes positioning, marketing copy, landing-page text, documentation and drafts of messages.",
-    kind: "artifact"
+  agy: {
+    label: "Antigravity",
+    binary: "agy",
+    provider: "antigravity-cli",
+    signIn: "run `agy` in a terminal and sign in"
   }
-];
-function resolveRoles(config) {
-  const roles = new Map(DEFAULT_ROLES.map((r) => [r.id, { ...r }]));
-  for (const [id, override] of Object.entries(config.roles)) {
-    const base = roles.get(id);
-    const role = {
-      id,
-      description: override.description ?? base?.description ?? id,
-      kind: override.kind ?? base?.kind ?? "artifact"
-    };
-    if (override.route) role.route = override.route;
-    const instructions = override.instructions ?? base?.instructions;
-    if (instructions) role.instructions = instructions;
-    roles.set(id, role);
+};
+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="
+      ];
   }
-  return [...roles.values()];
 }
-function publicRoles(roles) {
-  return roles.map(
-    ({ id, description, route }) => route ? { id, description, route } : { id, description }
-  );
+function realPath(p) {
+  try {
+    return realpathSync.native(p);
+  } catch {
+    return path8.resolve(p);
+  }
 }
-var OUTBOUND = [
-  /\b(send|sending|email|e-mail|emailing|mail out)\b/i,
-  /\b(tweet|dm|direct message|share on)\b/i,
-  /\b(post|publish)\b[^.\n]{0,60}\b(on|to)\b/i,
-  /\b(pay|purchase|buy|checkout|subscribe to|sign up|signup|register (for|on|at))\b/i,
-  /\b(outreach|cold[- ]?(call|email)|contact (the|our|potential|prospects?|customers?|leads?))\b/i,
-  /\b(launch (the )?ads?|run (the )?ads?|ad campaign|deploy to production|go live)\b/i
-];
-var OPERATIONAL = [
-  /\b(deploy|release|publish)\b[^.\n]*\b(production|prod|npm|app store|play store|live)\b/i,
-  /\b(go live|pay|purchase|buy|checkout)\b/i,
-  /\b(send|email|e-mail|message)\b[^.\n]*\b(customers?|users?|leads?|prospects?|subscribers?|mailing list|newsletter)\b/i,
-  /\b(post|tweet|publish)\b[^.\n]*\b(twitter|x\.com|linkedin|facebook|instagram|reddit|hacker news|product hunt)\b/i
-];
-function firstMatch(patterns, text) {
-  for (const pattern of patterns) {
-    const match = pattern.exec(text);
-    if (match) return match[0];
+function agentStdin(agent, mode, prompt) {
+  if (agent === "agy") {
+    const content = mode === "plan" ? `${AGY_PLAN_NOTE}
+
+${prompt}` : prompt;
+    return `${JSON.stringify({ event: "user", message: { content } })}
+`;
   }
-  return void 0;
+  if (agent === "claude" && prompt.trimStart().startsWith("/")) return `Task:
+${prompt}`;
+  return prompt;
 }
-function outboundAction(text) {
-  return firstMatch(OUTBOUND, text);
+function abortError() {
+  const err = new Error("The agent run was aborted");
+  err.name = "AbortError";
+  return err;
 }
-var DRAFT_NOTICE = "DaveCode never performs outbound actions (emails, posts, payments, sign-ups, deployments). Produce a ready-to-use DRAFT for a human to review and execute.";
-function applySafetyGuard(task) {
-  const text = `${task.title}
-${task.description ?? ""}`;
-  const action = task.kind === "code" ? firstMatch(OPERATIONAL, text) : firstMatch(OUTBOUND, text);
-  if (!action) return task;
-  const title = /^draft\b/i.test(task.title) ? task.title : `Draft: ${task.title}`;
-  const description = [task.description?.trim(), DRAFT_NOTICE].filter(Boolean).join("\n\n");
-  return { ...task, kind: "artifact", title: title.slice(0, 300), description };
+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();
 }
-var plannedTaskSchema = z10.object({
-  id: z10.string().min(1).max(80),
-  title: z10.string().trim().min(1).max(300),
-  description: z10.string().max(8e3).optional(),
-  role: z10.string().min(1).max(40),
-  kind: z10.enum(["code", "artifact"]).optional(),
-  dependsOn: z10.array(z10.string().min(1)).max(50).default([]),
-  acceptance: z10.array(z10.string().min(1).max(1e3)).max(20).optional()
-});
-var planSchema = z10.object({
-  summary: z10.string().max(4e3).optional(),
-  tasks: z10.array(plannedTaskSchema).min(1).max(100)
-});
-var reviewSchema = z10.object({
-  /** The objective is achieved as far as DaveCode can take it. */
-  done: z10.boolean(),
-  summary: z10.string().max(8e3),
-  /** Ids of FAILED tasks worth another attempt. */
-  retry: z10.array(z10.string()).max(50).default([]),
-  /** New tasks for the next round. */
-  tasks: z10.array(plannedTaskSchema).max(50).default([])
-});
-var TASK_ID = /^[a-z0-9]+(?:[-_.][a-z0-9]+)*$/;
-function sanitizeTaskId(raw) {
-  const id = raw.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60).replace(/-+$/g, "");
-  return TASK_ID.test(id) ? id : "task";
+function clip(text, max) {
+  return text.length <= max ? text : `${text.slice(0, max - 1)}\u2026`;
 }
-function normalizeTasks(planned, opts) {
-  const roleById = new Map(opts.roles.map((r) => [r.id, r]));
-  const taken = new Set(opts.existing.map((t) => t.id));
-  const idMap = /* @__PURE__ */ new Map();
-  const out = [];
-  for (const p of planned.slice(0, Math.max(0, opts.room))) {
-    let id = sanitizeTaskId(p.id);
-    for (let n = 2; taken.has(id); n++) id = `${sanitizeTaskId(p.id)}-${n}`;
-    taken.add(id);
-    idMap.set(p.id, id);
-    let role = roleById.get(p.role.toLowerCase());
-    const requested = p.kind ?? role?.kind ?? "artifact";
-    if (!role)
-      role = roleById.get(requested === "code" ? "implementer" : "writer") ?? opts.roles[0];
-    const kind = requested === "code" && opts.codeTasks ? "code" : "artifact";
-    const task = {
-      id,
-      title: p.title,
-      role: role?.id ?? "writer",
-      kind,
-      status: "PENDING",
-      dependsOn: p.dependsOn,
-      round: opts.round,
-      attempts: 0
-    };
-    const description = requested === "code" && kind === "artifact" ? [
-      p.description,
-      "Code tasks cannot run here: write a precise implementation plan instead."
-    ].filter(Boolean).join("\n\n") : p.description;
-    if (description) task.description = description;
-    if (p.acceptance?.length) task.acceptance = p.acceptance;
-    out.push(applySafetyGuard(task));
-  }
-  const known = /* @__PURE__ */ new Set([...opts.existing.map((t) => t.id), ...out.map((t) => t.id)]);
-  for (const task of out) {
-    task.dependsOn = [
-      ...new Set(task.dependsOn.map((d) => idMap.get(d) ?? sanitizeTaskId(d)))
-    ].filter((d) => d !== task.id && known.has(d));
-  }
-  for (; ; ) {
-    const graph = {
-      version: 1,
-      tasks: [...opts.existing, ...out].map((t) => ({
-        id: t.id,
-        title: t.title,
-        status: t.status,
-        dependsOn: t.dependsOn
-      }))
-    };
-    const cycle = findCycles(graph)[0];
-    if (!cycle) break;
-    const from = cycle[cycle.length - 2];
-    const to = cycle[cycle.length - 1];
-    const task = out.find((t) => t.id === from);
-    if (!task) break;
-    task.dependsOn = task.dependsOn.filter((d) => d !== to);
-  }
-  return out;
-}
-var SAFETY_RULES = `Hard rules (non-negotiable):
-- You run inside DaveCode with no internet access and no ability to contact anyone.
-- Never send emails or messages, post or publish anything, make payments or purchases, sign up for services, or deploy. When such a step is useful, produce a DRAFT for a human to review and execute.
-- Never invent credentials, personal data or facts presented as verified; label assumptions and estimates clearly.
-- Stay within the objective; prefer concrete, actionable outputs.`;
-function roleList(roles) {
-  return roles.map((r) => `- ${r.id} (${r.kind}): ${r.description}`).join("\n");
+function shortError(text) {
+  return clip(scrubSecrets(text), MAX_ERROR);
 }
-function plannerPrompt(roles, codeTasks) {
-  return `You are the planner of a small team of AI agents working toward one objective. Decompose the objective into a dependency graph of concrete tasks and assign each task to one role.
-
-Roles:
-${roleList(roles)}
-
-Task kinds:
-- "artifact": the role writes one markdown document (analysis, plan, copy, checklist, draft).
-- "code": the implementer changes the repository; an autonomous runner branches, runs the quality gates and merges.${codeTasks ? "" : "\n  Code tasks are NOT available in this workspace: plan artifact tasks only."}
-
-${SAFETY_RULES}
-
-Plan at most the number of tasks you are allowed, smallest useful set first. Ids are short lowercase kebab-case. Use dependsOn so later tasks build on earlier outputs.
-
-Respond with ONLY a JSON object, no prose and no code fences:
-{"summary": "one paragraph plan", "tasks": [{"id": "market-research", "title": "...", "description": "...", "role": "researcher", "kind": "artifact", "dependsOn": [], "acceptance": ["..."]}]}`;
+function formatDuration(ms) {
+  if (ms >= 6e4) return `${Math.round(ms / 6e4)} min`;
+  return `${Math.max(1, Math.ceil(ms / 1e3))} s`;
 }
-var REVIEWER_PROMPT = `You are the reviewer of a team of AI agents working toward one objective. Judge the results so far against the objective.
-
-${SAFETY_RULES}
-
-Decide:
-- "done": true when the objective is achieved as far as an offline team can take it (remaining steps are outbound actions a human must do from the drafts).
-- otherwise propose the next round: "retry" lists FAILED task ids worth another attempt, "tasks" lists new tasks (same shape as the planner's, dependsOn may reference existing ids).
-
-Respond with ONLY a JSON object, no prose and no code fences:
-{"done": false, "summary": "progress, gaps and what a human must do next", "retry": [], "tasks": []}`;
-function roleSystemPrompt(role) {
-  return [
-    `You are the ${role.id} of a small team of AI agents. ${role.description}`,
-    SAFETY_RULES,
-    "Write your deliverable as a single, well-structured markdown document. Do not wrap it in code fences. Start with a level-1 heading.",
-    role.instructions?.trim()
-  ].filter(Boolean).join("\n\n");
+function tail(text, max = 400) {
+  const t = text.trim();
+  return t.length <= max ? t : t.slice(t.length - max);
 }
-var MeteredExecutor = class {
-  constructor(inner) {
-    this.inner = inner;
-  }
-  inner;
-  tokens = 0;
-  get name() {
-    return this.inner.name;
-  }
-  createSession(task) {
-    const session = this.inner.createSession(task);
-    return {
-      run: async (opts) => {
-        const result = await session.run(opts);
-        this.tokens += Math.max(0, result.tokens);
-        return result;
+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;
       }
-    };
+    }
   }
-};
-var MIN_TASK_TOKENS = 1e4;
-var RunnerCodeTasks = class {
-  constructor(options) {
-    this.options = options;
-    this.owner = options.owner ?? "goal";
+  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;
+      }
+    }
   }
-  options;
-  owner;
-  async available() {
-    const { brain, engine } = this.options;
-    const git = new Git(brain.root);
-    if (!await git.isRepo())
-      return { ok: false, reason: `${brain.root} is not a git repository` };
-    if (!await brain.isInitialised()) {
-      return { ok: false, reason: "the project brain is missing (run davecode init)" };
+  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;
+      }
     }
-    const base = engine.config.runner.baseBranch;
-    if (!await git.branchExists(base)) {
-      return { ok: false, reason: `base branch "${base}" does not exist` };
+  };
+}
+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);
     }
-    if ((await git.status({ ignoreBrain: true })).length > 0) {
-      return { ok: false, reason: "the working tree has uncommitted changes" };
+    case "mcp_tool_call": {
+      const name = [asString(item.server), asString(item.tool)].filter(Boolean).join(".");
+      return toolLine(name || "MCP tool", void 0, cwd);
     }
-    return { ok: true };
+    case "web_search":
+      return toolLine("Search", { query: asString(item.query) ?? "" }, cwd);
+    default:
+      return toolLine(type, item, cwd);
   }
-  async run(task, opts) {
-    const { brain, engine } = this.options;
-    const runnerTaskId = sanitizeTaskId(`goal-${opts.goal.id.slice(-6)}-${task.id}`);
-    const graph = await brain.readGraph();
-    const existing = graph.tasks.find((t) => t.id === runnerTaskId);
-    if (existing?.status === "SUCCESS") {
-      return { ok: true, summary: existing.notes ?? "already done", tokens: 0, runnerTaskId };
-    }
-    if (!existing) {
-      await brain.createTask({
-        id: runnerTaskId,
-        title: task.title,
-        description: [
-          task.description,
-          `Part of DaveCode goal ${opts.goal.id}: ${opts.goal.objective}`
-        ].filter(Boolean).join("\n\n"),
-        ...task.acceptance?.length ? { acceptance: task.acceptance } : {}
-      });
-    } else if (existing.status !== "PENDING") {
-      await brain.setTaskStatus(runnerTaskId, "PENDING", { notes: "retried by goal mode" });
-    }
-    const base = engine.config.runner;
-    const config = {
-      ...base,
-      maxTaskTokens: Math.max(MIN_TASK_TOKENS, Math.min(base.maxTaskTokens, opts.maxTokens))
-    };
-    const metered = new MeteredExecutor(this.options.executor ?? createExecutor(engine, config));
-    const runner = this.options.makeRunner?.(config, metered) ?? createRunner(engine, {
-      brain,
-      config,
-      executor: metered,
-      lock: { lock: this.options.lock, owner: this.owner },
-      ...this.options.contextExtras ? { contextExtras: this.options.contextExtras } : {}
-    });
-    const onAbort = () => void runner.stop();
-    opts.signal.addEventListener("abort", onAbort, { once: true });
-    try {
-      const result = await runner.runOnce({ taskId: runnerTaskId });
-      return {
-        ok: result.outcome === "success",
-        summary: result.summary ?? result.error ?? result.outcome,
-        tokens: metered.tokens,
-        runnerTaskId,
-        ...result.outcome === "stopped" ? { stopped: true } : {}
-      };
-    } catch (err) {
-      if (!(err instanceof RunnerError)) throw err;
-      return { ok: false, summary: err.message, tokens: metered.tokens, runnerTaskId };
-    } finally {
-      opts.signal.removeEventListener("abort", onAbort);
-    }
-  }
-};
-var TERMINAL = /* @__PURE__ */ new Set([
-  "planned",
-  "succeeded",
-  "failed",
-  "cancelled",
-  "budget_exhausted"
-]);
-function isTerminalGoal(goal) {
-  return TERMINAL.has(goal.status);
 }
-var Cancelled = class extends Error {
-};
-var OutOfBudget = class extends Error {
-};
-var MAX_DEP_CHARS = 6e3;
-var MAX_DEPS_TOTAL = 2e4;
-var MAX_REVIEW_EXCERPT = 1500;
-var MAX_TOOL_ROUNDS = 6;
-var GoalOrchestrator = class {
-  constructor(options) {
-    this.options = options;
-    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
-    this.tools = new WorkspaceTools({ root: options.store.root, readOnly: true });
-  }
-  options;
-  now;
-  tools;
-  /** A fresh goal (not yet persisted) with limits clamped to the config. */
-  create(input) {
-    const cfg = this.options.config;
-    const stamp = this.now().toISOString();
-    const goal = {
-      id: newId2("goal", 6),
-      objective: input.objective.trim(),
-      status: "planning",
-      round: 0,
-      limits: {
-        maxRounds: Math.min(input.maxRounds ?? cfg.maxRounds, cfg.maxRounds),
-        maxTasks: Math.min(input.maxTasks ?? cfg.maxTasks, cfg.maxTasks),
-        maxTokens: Math.min(input.maxTokens ?? cfg.maxTokens, cfg.maxTokens),
-        tokensUsed: 0
-      },
-      roles: publicRoles(resolveRoles(cfg)),
-      tasks: [],
-      createdAt: stamp,
-      updatedAt: stamp
-    };
-    if (input.dryRun) goal.dryRun = true;
-    return goal;
-  }
-  /** Runs `goal` to a terminal status. Never throws: failures end up in `status`/`lastError`. */
-  async run(goal, signal) {
-    const cfg = this.options.config;
-    const roles = resolveRoles(cfg);
-    try {
-      const code = await this.codeAvailability();
-      if (!code.ok) this.log(goal, "info", `code tasks disabled: ${code.reason}`);
-      if (goal.round === 0 || goal.tasks.length === 0) {
-        goal.round = 1;
-        await this.update(goal, { status: "planning" });
-        this.log(goal, "info", `planning: ${goal.objective}`, "planner");
-        const plan = await this.plan(goal, roles, code.ok, signal);
-        goal.tasks = normalizeTasks(plan.tasks, {
-          existing: [],
-          roles,
-          round: 1,
-          room: goal.limits.maxTasks,
-          codeTasks: code.ok
-        });
-        if (plan.summary) goal.summary = plan.summary;
-        this.log(goal, "info", `planned ${goal.tasks.length} task(s)`, "planner");
-        if (goal.dryRun) return await this.finish(goal, "planned");
-      } else {
-        this.log(goal, "info", `executing planned goal (${goal.tasks.length} task(s))`, "planner");
+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;
       }
-      for (; ; ) {
-        await this.update(goal, { status: "running" });
-        await this.executeReady(goal, roles, signal);
-        await this.update(goal, { status: "reviewing" });
-        this.log(goal, "info", `reviewing round ${goal.round}`, "reviewer");
-        const review = await this.review(goal, roles, signal);
-        goal.summary = review.summary;
-        if (review.done) return await this.finish(goal, "succeeded");
-        if (goal.round >= goal.limits.maxRounds) {
-          goal.lastError = `reached ${goal.limits.maxRounds} round(s) without completing the objective`;
-          return await this.finish(goal, "failed");
+      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;
         }
-        const retried = this.applyRetries(goal, review.retry);
-        const added = normalizeTasks(review.tasks, {
-          existing: goal.tasks,
-          roles,
-          round: goal.round + 1,
-          room: goal.limits.maxTasks - goal.tasks.length,
-          codeTasks: code.ok
-        });
-        if (retried === 0 && added.length === 0) {
-          goal.lastError = goal.tasks.length >= goal.limits.maxTasks ? `reached the cap of ${goal.limits.maxTasks} task(s) without completing the objective` : "the reviewer proposed no further work but the objective is not done";
-          return await this.finish(goal, "failed");
+        if (itemType === "error") {
+          const message = asString(item.message);
+          if (message && type === "item.completed")
+            emit({ kind: "error", text: shortError(message) });
+          return;
         }
-        goal.tasks.push(...added);
-        goal.round++;
-        this.log(
-          goal,
-          "info",
-          `round ${goal.round}: ${added.length} new task(s), ${retried} retried`,
-          "reviewer"
-        );
+        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;
       }
-    } catch (err) {
-      for (const task of goal.tasks) if (task.status === "IN_PROGRESS") task.status = "PENDING";
-      delete goal.activeTaskId;
-      if (err instanceof Cancelled || signal.aborted) return await this.finish(goal, "cancelled");
-      if (err instanceof OutOfBudget) {
-        goal.lastError = err.message;
-        return await this.finish(goal, "budget_exhausted");
+      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;
       }
-      goal.lastError = err instanceof Error ? err.message : String(err);
-      this.log(goal, "error", goal.lastError);
-      return await this.finish(goal, "failed");
-    }
-  }
-  // -- phases -----------------------------------------------------------------
-  async codeAvailability() {
-    if (!this.options.config.codeTasks) return { ok: false, reason: "goal.codeTasks is off" };
-    if (!this.options.codeRunner) return { ok: false, reason: "no project runner available" };
-    try {
-      return await this.options.codeRunner.available();
-    } catch (err) {
-      return { ok: false, reason: err instanceof Error ? err.message : String(err) };
-    }
-  }
-  async plan(goal, roles, codeTasks, signal) {
-    const user = [
-      `OBJECTIVE:
-${goal.objective}`,
-      `You may plan at most ${goal.limits.maxTasks} task(s) in total; the team has ${goal.limits.maxRounds} round(s) of plan \u2192 execute \u2192 review.`,
-      await this.sharedContext()
-    ].filter(Boolean).join("\n\n");
-    return this.askJson(
-      planSchema,
-      goal,
-      this.roleFor(roles, "planner"),
-      plannerPrompt(roles, codeTasks),
-      user,
-      signal
-    );
-  }
-  async review(goal, roles, signal) {
-    const lines2 = [];
-    for (const task of goal.tasks) {
-      lines2.push(
-        `- [${task.status}] ${task.id} (${task.role}, ${task.kind}, round ${task.round}, ${task.attempts} attempt(s)): ${task.title}`
-      );
-      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)
-          lines2.push(`  output excerpt:
-${indent(truncateHead(text, MAX_REVIEW_EXCERPT))}`);
+      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) });
+        }
       }
     }
-    const user = [
-      `OBJECTIVE:
-${goal.objective}`,
-      `Round ${goal.round} of ${goal.limits.maxRounds}. Room for ${Math.max(0, goal.limits.maxTasks - goal.tasks.length)} more task(s).`,
-      `TASKS:
-${lines2.join("\n")}`,
-      await this.sharedContext()
-    ].filter(Boolean).join("\n\n");
-    return this.askJson(
-      reviewSchema,
-      goal,
-      this.roleFor(roles, "reviewer"),
-      REVIEWER_PROMPT,
-      user,
-      signal
-    );
-  }
-  /** Runs ready tasks until none is left; failed tasks are retried up to `maxTaskAttempts`. */
-  async executeReady(goal, roles, signal) {
-    for (; ; ) {
-      const task = readyGoalTasks(goal)[0];
-      if (!task) return;
-      this.checkpoint(goal, signal);
-      task.attempts++;
-      task.status = "IN_PROGRESS";
-      await this.update(goal, { activeTaskId: task.id });
-      this.log(goal, "info", `${task.title} (attempt ${task.attempts})`, task.role, task.id);
-      try {
-        if (task.kind === "code") await this.runCodeTask(goal, task, signal);
-        else await this.runArtifactTask(goal, task, this.roleFor(roles, task.role), signal);
-        const outcome = task.status;
-        this.log(
-          goal,
-          outcome === "SUCCESS" ? "info" : "warn",
-          `${task.id}: ${outcome}`,
-          task.role,
-          task.id
-        );
-      } catch (err) {
-        if (err instanceof Cancelled || err instanceof OutOfBudget || signal.aborted) throw err;
-        if (err instanceof RouterError && (err.code === "no_capacity" || err.code === "rate_limited")) {
-          throw new OutOfBudget(`no account has capacity left (${err.message})`);
+  };
+}
+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;
         }
-        task.status = "FAILED";
-        task.notes = truncateHead(err instanceof Error ? err.message : String(err), 2e3);
-        this.log(goal, "warn", `${task.id} failed: ${task.notes}`, task.role, task.id);
+        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 (task.status === "FAILED" && task.attempts < this.options.config.maxTaskAttempts) {
-        task.status = "PENDING";
+      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();
       }
-      delete goal.activeTaskId;
-      await this.update(goal, {});
     }
-  }
-  async runArtifactTask(goal, task, role, signal) {
-    const parts = [`OBJECTIVE OF THE TEAM:
-${goal.objective}`, `YOUR TASK: ${task.title}`];
-    if (task.description) parts.push(task.description);
-    if (task.acceptance?.length) {
-      parts.push(`Acceptance criteria:
-${task.acceptance.map((c) => `- ${c}`).join("\n")}`);
+  };
+}
+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;
     }
-    let budget = MAX_DEPS_TOTAL;
-    for (const depId of task.dependsOn) {
-      const dep = goal.tasks.find((t) => t.id === depId);
-      if (!dep || budget <= 0) continue;
-      const text = dep.artifact ? await this.options.store.readArtifact(goal.id, dep.id) : dep.notes;
-      if (!text) continue;
-      const excerpt = truncateHead(text, Math.min(MAX_DEP_CHARS, budget));
-      budget -= excerpt.length;
-      parts.push(`OUTPUT OF ${dep.id} (${dep.role}): ${dep.title}
-${excerpt}`);
+  };
+  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 shared = await this.sharedContext(false);
-    if (shared) parts.push(shared);
-    const reply = (await this.ask(goal, role, roleSystemPrompt(role), parts.join("\n\n"), signal)).trim();
-    if (!reply) throw new Error("the agent returned an empty reply");
-    task.artifact = await this.options.store.writeArtifact(goal.id, task.id, stripFence(reply));
-    task.status = "SUCCESS";
-    task.notes = `Wrote ${task.artifact}`;
-  }
-  async runCodeTask(goal, task, signal) {
-    const runner = this.options.codeRunner;
-    if (!runner) throw new Error("no project runner available for code tasks");
-    const result = await runner.run(task, {
-      goal,
-      maxTokens: goal.limits.maxTokens - goal.limits.tokensUsed,
-      signal
-    });
-    this.addTokens(goal, result.tokens);
-    if (result.runnerTaskId) task.runnerTaskId = result.runnerTaskId;
-    if (result.stopped || signal.aborted) throw new Cancelled();
-    task.status = result.ok ? "SUCCESS" : "FAILED";
-    task.notes = truncateHead(result.summary || (result.ok ? "done" : "failed"), 2e3);
-  }
-  applyRetries(goal, ids) {
-    let count = 0;
-    for (const id of new Set(ids)) {
-      const task = goal.tasks.find((t) => t.id === id);
-      if (task?.status !== "FAILED") continue;
-      task.status = "PENDING";
-      task.attempts = 0;
-      count++;
+    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;
     }
-    return count;
-  }
-  // -- model calls ------------------------------------------------------------
-  roleFor(roles, id) {
-    return roles.find((r) => r.id === id) ?? { id, description: id, kind: "artifact" };
-  }
-  async ask(goal, role, system, user, signal) {
-    const model = routeModel(role.route ?? this.options.config.route);
-    const messages = [
-      { role: "system", content: system },
-      { role: "user", content: user }
-    ];
-    let attachTools = this.options.readTools === true;
-    for (let round = 0; round <= MAX_TOOL_ROUNDS; round++) {
-      this.checkpoint(goal, signal);
-      const allowTools = attachTools && round < MAX_TOOL_ROUNDS;
-      let completion;
+    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 {
-        ({ completion } = await this.options.router.complete(
-          {
-            model,
-            messages,
-            ...allowTools ? { tools: [...READ_ONLY_TOOL_DEFINITIONS] } : {}
-          },
-          { signal }
-        ));
+        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 (allowTools && err instanceof RouterError && err.code === "no_available_account") {
-          attachTools = false;
-          ({ completion } = await this.options.router.complete({ model, messages }, { signal }));
-        } else {
-          throw err;
-        }
+        if (request.signal.aborted) throw abortError();
+        if (timeout.aborted) return timedOut();
+        return { ok: false, text: "", error: shortError(errText(err)) };
       }
-      const message = completion.choices[0]?.message;
-      const content = message?.content;
-      const text = typeof content === "string" ? content : "";
-      const usage = completion.usage;
-      this.addTokens(
-        goal,
-        usage && usage.prompt_tokens + usage.completion_tokens > 0 ? usage.prompt_tokens + usage.completion_tokens : countTextTokens(system) + countTextTokens(user) + countTextTokens(text)
-      );
-      const calls = message?.tool_calls ?? [];
-      if (calls.length === 0 || round === MAX_TOOL_ROUNDS) return text;
-      messages.push({ role: "assistant", content: content ?? null, tool_calls: calls });
-      for (const call of calls) {
-        this.log(goal, "debug", `tool ${call.function.name}`, role.id, goal.activeTaskId);
-        const outcome = await this.tools.call(call.function.name, call.function.arguments, signal);
-        messages.push({
-          role: "tool",
-          tool_call_id: call.id,
-          name: call.function.name,
-          content: outcome.output
-        });
-      }
-    }
-    return "";
-  }
-  /** Asks for a JSON reply matching `schema`; one corrective retry on malformed output. */
-  async askJson(schema, goal, role, system, user, signal) {
-    let problem = "";
-    for (let attempt = 0; attempt < 2; attempt++) {
-      const prompt = attempt === 0 ? user : `${user}
-
-Your previous reply was rejected (${problem}). Respond with ONLY the JSON object in the required shape.`;
-      const reply = await this.ask(goal, role, system, prompt, signal);
+      const parser = PARSERS[request.agent](emit, cwd);
+      let streamError;
       try {
-        const parsed = schema.safeParse(extractJsonObject(reply));
-        if (parsed.success) return parsed.data;
-        problem = parsed.error.issues.slice(0, 3).map((i) => `${i.path.join(".") || "reply"}: ${i.message}`).join("; ");
+        for await (const event of cli.events) parser.handle(event);
       } catch (err) {
-        problem = err instanceof Error ? err.message : String(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 {
+        }
       }
-      this.log(goal, "warn", `invalid JSON from the ${role.id}: ${problem}`, role.id);
-    }
-    throw new Error(`the ${role.id} did not return valid JSON (${problem})`);
-  }
-  async sharedContext(includeProject = true) {
-    const parts = [];
-    if (includeProject && this.options.projectContext) {
-      const project = (await this.options.projectContext()).trim();
-      if (project) parts.push(`PROJECT CONTEXT:
-${project}`);
-    }
-    if (this.options.budgetContext) {
-      const budget = (await this.options.budgetContext()).trim();
-      if (budget) parts.push(budget);
     }
-    return parts.join("\n\n");
   }
-  // -- bookkeeping ------------------------------------------------------------
-  checkpoint(goal, signal) {
-    if (signal.aborted) throw new Cancelled();
-    if (goal.limits.tokensUsed >= goal.limits.maxTokens) {
-      throw new OutOfBudget(
-        `token budget exhausted (${goal.limits.tokensUsed}/${goal.limits.maxTokens})`
+  return {
+    async availability() {
+      return ORCHESTRATOR_AGENTS.map((agent) => ({ agent, available: isAvailable(agent) }));
+    },
+    run
+  };
+}
+function errText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function tokens(out) {
+  const parts = out.split("\0");
+  if (parts.at(-1) === "") parts.pop();
+  return parts;
+}
+function statusOf(letter) {
+  switch (letter[0]) {
+    case "A":
+      return "added";
+    case "D":
+      return "deleted";
+    case "R":
+      return "renamed";
+    case "C":
+      return "added";
+    default:
+      return "modified";
+  }
+}
+function parseNameStatus(out) {
+  const parts = tokens(out);
+  const files = [];
+  for (let i = 0; i < parts.length; ) {
+    const code = parts[i++] ?? "";
+    if (!code) continue;
+    if (code[0] === "R" || code[0] === "C") {
+      const oldPath = parts[i++] ?? "";
+      const path11 = parts[i++] ?? "";
+      files.push(
+        code[0] === "R" ? { path: path11, oldPath, status: "renamed" } : { path: path11, status: "added" }
       );
+    } else {
+      files.push({ path: parts[i++] ?? "", status: statusOf(code) });
     }
   }
-  addTokens(goal, tokens) {
-    if (Number.isFinite(tokens) && tokens > 0) goal.limits.tokensUsed += Math.round(tokens);
-  }
-  async update(goal, patch) {
-    Object.assign(goal, patch);
-    goal.updatedAt = this.now().toISOString();
-    await this.options.store.save(goal);
-    this.options.events.emit({ type: "goal.updated", goal: structuredClone(goal) });
-  }
-  async finish(goal, status) {
-    delete goal.activeTaskId;
-    goal.finishedAt = this.now().toISOString();
-    await this.update(goal, { status });
-    this.log(
-      goal,
-      status === "succeeded" || status === "planned" ? "info" : "warn",
-      `goal ${status}${goal.lastError ? `: ${goal.lastError}` : ""} (${goal.limits.tokensUsed} tokens)`
-    );
-    return goal;
-  }
-  log(goal, level, message, role, taskId) {
-    this.options.events.emit({
-      type: "goal.log",
-      goalId: goal.id,
-      level,
-      message,
-      ...role ? { role } : {},
-      ...taskId ? { taskId } : {}
+  return files.filter((f) => f.path.length > 0);
+}
+function parseNumStat(out) {
+  const parts = tokens(out);
+  const stats = /* @__PURE__ */ new Map();
+  for (let i = 0; i < parts.length; ) {
+    const head = parts[i++] ?? "";
+    const match = /^(-|\d+)\t(-|\d+)\t(.*)$/s.exec(head);
+    if (!match) continue;
+    const [, added = "0", deleted = "0", inline = ""] = match;
+    let path11 = inline;
+    if (inline === "") {
+      i++;
+      path11 = parts[i++] ?? "";
+    }
+    const binary = added === "-" || deleted === "-";
+    stats.set(path11, {
+      additions: binary ? 0 : Number(added),
+      deletions: binary ? 0 : Number(deleted),
+      binary
     });
   }
-};
-function readyGoalTasks(goal) {
-  const status = new Map(goal.tasks.map((t) => [t.id, t.status]));
-  return goal.tasks.filter(
-    (t) => t.status === "PENDING" && t.dependsOn.every((d) => status.get(d) === "SUCCESS")
-  );
+  return stats;
 }
-function indent(text) {
-  return text.split("\n").map((l) => `    ${l}`).join("\n");
+function mergeFileLists(tracked, stats, untracked) {
+  const files = tracked.map((file) => {
+    const stat4 = stats.get(file.path) ?? { additions: 0, deletions: 0, binary: false };
+    return { ...file, ...stat4 };
+  });
+  const seen = new Set(files.map((f) => f.path));
+  for (const file of untracked) if (!seen.has(file.path)) files.push(file);
+  return files.sort((a, b) => a.path.localeCompare(b.path));
 }
-function stripFence(text) {
-  const match = /^```(?:markdown|md)?\s*\n([\s\S]*?)\n```\s*$/i.exec(text);
-  return match?.[1] ?? text;
+function looksBinary(content) {
+  return content.subarray(0, 8e3).includes(0);
 }
-var GoalError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "GoalError";
-    this.statusCode = code === "not_found" ? 404 : code === "invalid" ? 400 : 409;
+function countLines(text) {
+  if (text.length === 0) return 0;
+  const breaks = text.split("\n").length - 1;
+  return text.endsWith("\n") ? breaks : breaks + 1;
+}
+function newFilePatch(path11, content) {
+  const header = `diff --git a/${path11} b/${path11}
+new file mode 100644
+`;
+  if (!content || looksBinary(content)) {
+    return `${header}Binary files /dev/null and b/${path11} differ
+`;
   }
-  code;
-  /** HTTP status hint for the gateway. */
-  statusCode;
-};
-var GoalService = class {
-  constructor(options) {
-    this.options = options;
-    this.owner = options.owner ?? "goal";
-    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const text = content.toString("utf8");
+  if (text.length === 0) return header;
+  const lines2 = text.split("\n");
+  const trailingNewline = text.endsWith("\n");
+  if (trailingNewline) lines2.pop();
+  const body = lines2.map((line) => `+${line}`).join("\n");
+  const hunk = `@@ -0,0 +1,${lines2.length} @@
+${body}
+`;
+  return `${header}--- /dev/null
++++ b/${path11}
+${hunk}${trailingNewline ? "" : "\\n"}`;
+}
+function slugify(text, max = 40) {
+  const slug = text.toLowerCase().normalize("NFKD").replace(/[̀-ͯ]/g, "").replace(/^[a-z]+(\([^)]*\))?!?:\s*/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, max).replace(/-+$/g, "");
+  return slug || "changes";
+}
+function scrubUrls(text) {
+  return text.replace(/(\b[a-z][a-z0-9+.-]*:\/\/)[^/@\s]+@/gi, "$1***@");
+}
+var DOC = /(^|\/)docs?\/|\.(md|mdx|txt|rst)$/i;
+var TEST = /(^|\/)(__tests__|tests?)\/|\.(test|spec)\.[a-z0-9]+$/i;
+var PACKAGE = /^(?:packages|apps|libs|services)\/([^/]+)\//;
+var MAX_LISTED = 30;
+function basename3(path11) {
+  return path11.split("/").at(-1) ?? path11;
+}
+function commitType(files) {
+  if (files.every((f) => DOC.test(f.path))) return "docs";
+  if (files.every((f) => TEST.test(f.path))) return "test";
+  return "chore";
+}
+function commitScope(files) {
+  const scopes = new Set(files.map((f) => PACKAGE.exec(f.path)?.[1]));
+  if (scopes.size !== 1) return void 0;
+  const [scope] = scopes;
+  return scope;
+}
+function subject(files) {
+  if (files.length === 1) {
+    const [file] = files;
+    const verb = file.status === "added" || file.status === "untracked" ? "add" : file.status === "deleted" ? "remove" : file.status === "renamed" ? "rename" : "update";
+    return `${verb} ${basename3(file.path)}`;
+  }
+  return `update ${files.length} files`;
+}
+function fileLine(file) {
+  const counts = file.binary ? "binary" : `+${file.additions} \u2212${file.deletions}`;
+  const from = file.oldPath ? ` (from \`${file.oldPath}\`)` : "";
+  return `- \`${file.path}\`${from} \u2014 ${counts}`;
+}
+function fallbackSuggestion(files) {
+  if (files.length === 0) {
+    return { message: "chore: update", title: "chore: update", body: "", by: "davecode" };
+  }
+  const scope = commitScope(files);
+  const message = `${commitType(files)}${scope ? `(${scope})` : ""}: ${subject(files)}`;
+  const listed = files.slice(0, MAX_LISTED).map(fileLine);
+  if (files.length > MAX_LISTED) listed.push(`- \u2026and ${files.length - MAX_LISTED} more`);
+  const body = `## Changes
+
+${listed.join("\n")}
+`;
+  return { message, title: message, body, by: "davecode" };
+}
+function agentPrompt(input) {
+  const max = CHANGES_LIMITS.suggestDiffMaxLength;
+  const patch = input.patch.length > max ? `${input.patch.slice(0, max)}
+[patch truncated]` : input.patch;
+  const files = input.files.map(
+    (f) => `${f.status} ${f.path}${f.binary ? " (binary)" : ` (+${f.additions} -${f.deletions})`}`
+  ).join("\n");
+  return [
+    "Write the git commit message and pull request text for the changes below.",
+    "Do not modify any file and do not run any command: only read the patch.",
+    "Reply with a single JSON object and nothing else (no code fence):",
+    '{"message": "<Conventional Commits subject, imperative mood, at most 72 characters>",',
+    ' "title": "<pull request title, at most 72 characters>",',
+    ' "body": "<pull request description in Markdown: one short paragraph, then a bullet list of the main changes>"}',
+    "Write in the same language as the code comments; default to English.",
+    "",
+    `Branch: ${input.branch ?? "(detached)"}`,
+    "Changed files:",
+    files,
+    "",
+    "Patch:",
+    patch
+  ].join("\n");
+}
+var agentReplySchema = z12.object({
+  message: z12.string().trim().min(1).max(CHANGES_LIMITS.messageMaxLength),
+  title: z12.string().trim().min(1).max(CHANGES_LIMITS.titleMaxLength),
+  body: z12.string().max(CHANGES_LIMITS.bodyMaxLength).default("")
+});
+function parseAgentSuggestion(text) {
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start < 0 || end <= start) return void 0;
+  let json;
+  try {
+    json = JSON.parse(text.slice(start, end + 1));
+  } catch {
+    return void 0;
   }
-  options;
-  active;
-  owner;
-  now;
-  get activeGoalId() {
-    return this.active?.goal.id;
+  const parsed = agentReplySchema.safeParse(json);
+  return parsed.success ? parsed.data : void 0;
+}
+var EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+var FALLBACK_IDENTITY = ["-c", "user.name=DaveCode", "-c", "user.email=davecode@localhost"];
+var SLOW_MS = 10 * 6e4;
+function paneWorktreesDir(home, projectDir) {
+  const key = createHash3("sha256").update(path9.resolve(projectDir)).digest("hex").slice(0, 16);
+  return path9.join(home, "panes", key);
+}
+function paneWorkspacePath(home, projectDir, id) {
+  if (!WORKSPACE_ID_PATTERN.test(id)) return void 0;
+  return path9.join(paneWorktreesDir(home, projectDir), id);
+}
+var metaSchema = z13.object({
+  id: z13.string().regex(WORKSPACE_ID_PATTERN),
+  label: z13.string(),
+  baseBranch: z13.string().optional(),
+  baseCommit: z13.string(),
+  createdAt: z13.string()
+});
+function short(err) {
+  const raw = err instanceof GitError ? err.stderr || err.message : err instanceof Error ? err.message : String(err);
+  const text = scrubSecrets(scrubUrls(raw));
+  return text.length <= 300 ? text : `${text.slice(0, 299)}\u2026`;
+}
+function nul(out) {
+  return out.split("\0").filter((f) => f.length > 0);
+}
+function samePath(a, b) {
+  const real = (p) => {
+    try {
+      return realpathSync2.native(p);
+    } catch {
+      return path9.resolve(p);
+    }
+  };
+  const [x, y] = [real(a), real(b)];
+  return process.platform === "win32" ? x.toLowerCase() === y.toLowerCase() : x === y;
+}
+function createChangesService(options) {
+  const projectDir = path9.resolve(options.projectDir);
+  const panesDir = paneWorktreesDir(options.home, projectDir);
+  const env = options.env ?? process.env;
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const gitAt = (cwd, slow = false) => new Git(cwd, { env, ...slow ? { timeoutMs: SLOW_MS } : {} });
+  const repo = gitAt(projectDir);
+  let queue = Promise.resolve();
+  const serial = (fn2) => {
+    const next = queue.then(fn2, fn2);
+    queue = next.catch(() => void 0);
+    return next;
+  };
+  const identity = /* @__PURE__ */ new Map();
+  async function identityArgs(g) {
+    if (identity.get(g.cwd)) return [];
+    try {
+      await g.run(["var", "GIT_AUTHOR_IDENT"]);
+      await g.run(["var", "GIT_COMMITTER_IDENT"]);
+      identity.set(g.cwd, true);
+      return [];
+    } catch {
+      return FALLBACK_IDENTITY;
+    }
   }
-  /** Validates, persists and starts a goal in the background. Resolves with its initial state. */
-  async start(input) {
-    if (!input.objective.trim()) throw new GoalError("invalid", "the objective is empty");
-    if (this.active) {
-      throw new GoalError("busy", `goal ${this.active.goal.id} is still running; cancel it first`);
+  async function assertRepo() {
+    if (!await repo.isRepo()) {
+      throw new ChangesError("not_a_repository", "This folder is not a git repository.");
     }
-    const lock = input.dryRun ? void 0 : this.options.lock;
-    if (lock && !lock.acquire(this.owner)) {
-      throw new GoalError(
-        "busy",
-        `the working tree is busy (${lock.holder ?? "another task"} is running)`
-      );
+    try {
+      return (await repo.run(["rev-parse", "--verify", "--quiet", "HEAD^{commit}"])).trim();
+    } catch {
+      throw new ChangesError("not_a_repository", "This repository has no commits yet.");
     }
+  }
+  const metaFile = (id) => path9.join(panesDir, `${id}.json`);
+  function readMeta(id) {
     try {
-      const goal = this.options.orchestrator.create(input);
-      await this.options.store.save(goal);
-      this.launch(goal, lock);
-      return structuredClone(goal);
-    } catch (err) {
-      lock?.release(this.owner);
-      throw err;
+      const parsed = metaSchema.safeParse(JSON.parse(readFileSync4(metaFile(id), "utf8")));
+      return parsed.success && parsed.data.id === id ? parsed.data : void 0;
+    } catch {
+      return void 0;
     }
   }
-  /**
-   * Executes a `planned` (dry-run) goal in the background without re-planning round 1.
-   * Resolves with the updated goal (`status: 'running'`).
-   */
-  async execute(id) {
-    if (this.active) {
-      throw new GoalError("busy", `goal ${this.active.goal.id} is still running; cancel it first`);
+  function isolatedIds() {
+    if (!existsSync5(panesDir)) return [];
+    return readdirSync(panesDir).filter((name) => name.endsWith(".json")).map((name) => name.slice(0, -5)).filter((id) => WORKSPACE_ID_PATTERN.test(id) && existsSync5(path9.join(panesDir, id)));
+  }
+  function target(id) {
+    if (id === MAIN_WORKSPACE_ID) {
+      return { id, label: path9.basename(projectDir), path: projectDir, isolated: false };
     }
-    const goal = await this.options.store.load(id);
-    if (!goal) throw new GoalError("not_found", `unknown goal "${id}"`);
-    if (goal.status !== "planned") {
-      throw new GoalError(
-        "invalid",
-        `goal "${id}" is ${goal.status}; only a planned goal can be executed`
-      );
-    }
-    const lock = this.options.lock;
-    if (lock && !lock.acquire(this.owner)) {
-      throw new GoalError(
-        "busy",
-        `the working tree is busy (${lock.holder ?? "another task"} is running)`
-      );
-    }
-    try {
-      delete goal.dryRun;
-      delete goal.finishedAt;
-      delete goal.lastError;
-      goal.status = "running";
-      goal.updatedAt = this.now().toISOString();
-      await this.options.store.save(goal);
-      this.launch(goal, lock);
-      return structuredClone(goal);
-    } catch (err) {
-      lock?.release(this.owner);
-      throw err;
+    const meta = WORKSPACE_ID_PATTERN.test(id) ? readMeta(id) : void 0;
+    const dir = path9.join(panesDir, id);
+    if (!meta || !existsSync5(dir)) throw new ChangesError("not_found", `unknown workspace "${id}"`);
+    return { id, label: meta.label, path: dir, isolated: true, meta };
+  }
+  async function optional(g, args) {
+    try {
+      const out = (await g.run(args)).trim();
+      return out || void 0;
+    } catch {
+      return void 0;
     }
   }
-  /** Reads the markdown artifact produced by `taskId` in goal `id`. */
-  async readArtifact(id, taskId) {
-    const goal = await this.get(id);
-    if (!goal) throw new GoalError("not_found", `unknown goal "${id}"`);
-    const task = goal.tasks.find((t) => t.id === taskId);
-    if (!task?.artifact) {
-      throw new GoalError("not_found", `task "${taskId}" has no artifact in goal "${id}"`);
-    }
-    const content = await this.options.store.readArtifact(id, taskId);
-    if (content === void 0) {
-      throw new GoalError("not_found", `artifact file for task "${taskId}" was not found`);
+  async function count(g, range) {
+    const out = await optional(g, ["rev-list", "--count", ...range]);
+    return out ? Number(out) || 0 : 0;
+  }
+  async function diffBase(g, t) {
+    const head = await optional(g, ["rev-parse", "--verify", "--quiet", "HEAD^{commit}"]);
+    if (!head) return EMPTY_TREE;
+    if (!t.isolated || !t.meta) return head;
+    if (t.meta.baseBranch) {
+      const base = await optional(g, ["merge-base", `refs/heads/${t.meta.baseBranch}`, "HEAD"]);
+      if (base) return base;
     }
-    return { taskId: task.id, path: task.artifact, content };
+    return await optional(g, ["merge-base", t.meta.baseCommit, "HEAD"]) ?? t.meta.baseCommit;
   }
-  launch(goal, lock) {
-    const controller = new AbortController();
-    const done = this.options.orchestrator.run(goal, controller.signal).catch((err) => {
-      goal.status = "failed";
-      goal.lastError = err instanceof Error ? err.message : String(err);
-      return goal;
-    }).finally(() => {
-      if (this.active?.goal === goal) this.active = void 0;
-      lock?.release(this.owner);
+  async function untrackedFiles(g, root) {
+    const paths = nul(await g.run(["ls-files", "--others", "--exclude-standard", "-z"]));
+    return paths.map((rel) => {
+      const content = readUntracked(root, rel);
+      const binary = !content || looksBinary(content);
+      return {
+        path: rel,
+        status: "untracked",
+        additions: binary ? 0 : countLines(content.toString("utf8")),
+        deletions: 0,
+        binary
+      };
     });
-    this.active = { goal, controller, done };
   }
-  async get(id) {
-    if (this.active?.goal.id === id) return structuredClone(this.active.goal);
-    return this.options.store.load(id);
+  function readUntracked(root, rel) {
+    const file = path9.join(root, rel);
+    try {
+      if (statSync4(file).size > CHANGES_LIMITS.untrackedMaxBytes) return void 0;
+      return readFileSync4(file);
+    } catch {
+      return void 0;
+    }
   }
-  /** Every goal of the workspace, newest first. */
-  async list() {
-    const stored = await this.options.store.list();
-    const active = this.active?.goal;
-    if (!active) return stored;
-    const rest = stored.filter((g) => g.id !== active.id);
-    return [structuredClone(active), ...rest];
+  async function changedFiles(g, t) {
+    const base = await diffBase(g, t);
+    const common = ["-c", "core.quotepath=false", "diff", "--no-ext-diff", "-M", "-z"];
+    const [names, stats, untracked] = await Promise.all([
+      g.run([...common, "--name-status", base]),
+      g.run([...common, "--numstat", base]),
+      untrackedFiles(g, t.path)
+    ]);
+    return { base, files: mergeFileLists(parseNameStatus(names), parseNumStat(stats), untracked) };
+  }
+  async function describe(t) {
+    const g = gitAt(t.path);
+    const [branch, { files }, porcelain, hasRemote] = await Promise.all([
+      optional(g, ["symbolic-ref", "--quiet", "--short", "HEAD"]),
+      changedFiles(g, t),
+      g.run(["status", "--porcelain", "-z", "--untracked-files=all"]),
+      g.hasRemote()
+    ]);
+    const upstream = branch ? await optional(g, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]) : void 0;
+    let ahead = 0;
+    let unpushed = 0;
+    if (t.isolated && t.meta) {
+      const base = t.meta.baseBranch ? `refs/heads/${t.meta.baseBranch}` : t.meta.baseCommit;
+      ahead = await count(g, [`${base}..HEAD`]);
+    }
+    if (upstream) unpushed = await count(g, ["@{u}..HEAD"]);
+    else if (t.isolated) unpushed = ahead;
+    else if (hasRemote) unpushed = await count(g, ["HEAD", "--not", "--remotes"]);
+    if (!t.isolated) ahead = unpushed;
+    return {
+      id: t.id,
+      label: t.label,
+      isolated: t.isolated,
+      path: t.path,
+      ...branch ? { branch } : {},
+      ...t.meta?.baseBranch ? { baseBranch: t.meta.baseBranch } : {},
+      files,
+      additions: files.reduce((sum, f) => sum + f.additions, 0),
+      deletions: files.reduce((sum, f) => sum + f.deletions, 0),
+      dirty: porcelain.length > 0,
+      ahead,
+      ...upstream ? { upstream } : {},
+      unpushed,
+      hasRemote,
+      ...t.meta ? { createdAt: t.meta.createdAt } : {}
+    };
   }
-  /**
-   * Cancels a running goal and resolves once it has stopped. A goal left unfinished by an earlier
-   * process is marked cancelled; a finished goal is returned unchanged.
-   */
-  async cancel(id) {
-    if (this.active?.goal.id === id) {
-      this.active.controller.abort();
-      return structuredClone(await this.active.done);
+  async function uniqueBranch(g, wanted) {
+    for (let n = 1; n < 100; n++) {
+      const name = n === 1 ? wanted : `${wanted}-${n}`;
+      if (!await g.branchExists(name)) return name;
     }
-    const goal = await this.options.store.load(id);
-    if (!goal) throw new GoalError("not_found", `unknown goal "${id}"`);
-    if (isTerminalGoal(goal)) return goal;
-    const stamp = this.now().toISOString();
-    goal.status = "cancelled";
-    goal.updatedAt = stamp;
-    goal.finishedAt = stamp;
-    delete goal.activeTaskId;
-    await this.options.store.save(goal);
-    return goal;
+    return `${wanted}-${randomBytes9(3).toString("hex")}`;
   }
-  /** Resolves when the goal is finished (immediately for stored goals). */
-  async wait(id) {
-    if (this.active?.goal.id === id) return structuredClone(await this.active.done);
-    return this.options.store.load(id);
-  }
-};
-var GOAL_ID = /^goal_[a-z0-9]{6,32}$/;
-var goalTaskSchema = z11.object({
-  id: z11.string().min(1),
-  title: z11.string(),
-  description: z11.string().optional(),
-  role: z11.string(),
-  kind: z11.enum(["code", "artifact"]),
-  status: taskStatusSchema,
-  dependsOn: z11.array(z11.string()),
-  acceptance: z11.array(z11.string()).optional(),
-  round: z11.number().int().min(1),
-  attempts: z11.number().int().min(0),
-  artifact: z11.string().optional(),
-  runnerTaskId: z11.string().optional(),
-  notes: z11.string().optional()
-});
-var goalSchema = z11.object({
-  id: z11.string().regex(GOAL_ID),
-  objective: z11.string().min(1),
-  status: z11.enum([
-    "planning",
-    "running",
-    "reviewing",
-    "planned",
-    "succeeded",
-    "failed",
-    "cancelled",
-    "budget_exhausted"
-  ]),
-  round: z11.number().int().min(0),
-  limits: z11.object({
-    maxRounds: z11.number().int().min(1),
-    maxTasks: z11.number().int().min(1),
-    maxTokens: z11.number().int().min(1),
-    tokensUsed: z11.number().int().min(0)
-  }),
-  roles: z11.array(
-    z11.object({ id: z11.string(), description: z11.string(), route: z11.string().optional() })
-  ),
-  tasks: z11.array(goalTaskSchema),
-  activeTaskId: z11.string().optional(),
-  summary: z11.string().optional(),
-  lastError: z11.string().optional(),
-  dryRun: z11.boolean().optional(),
-  createdAt: z11.string(),
-  updatedAt: z11.string(),
-  finishedAt: z11.string().optional()
-});
-function isGoalId(id) {
-  return GOAL_ID.test(id);
-}
-var GoalStore = class {
-  constructor(root) {
-    this.root = root;
-    this.dir = join7(projectPaths(root).dir, "goals");
+  async function defaultBranch(g) {
+    const head = await optional(g, [
+      "symbolic-ref",
+      "--quiet",
+      "--short",
+      "refs/remotes/origin/HEAD"
+    ]);
+    if (head?.startsWith("origin/")) return head.slice("origin/".length);
+    for (const name of ["main", "master"]) if (await g.branchExists(name)) return name;
+    return void 0;
   }
-  root;
-  dir;
-  goalDir(id) {
-    if (!isGoalId(id)) throw new Error(`invalid goal id: ${id}`);
-    return join7(this.dir, id);
+  function runGh(cwd, args) {
+    if (options.runGh) return options.runGh(cwd, args);
+    const gh = resolveOnPath(options.gh ?? "gh", env);
+    if (/\.(cmd|bat)$/i.test(gh)) {
+      return Promise.reject(new Error("gh is a shell shim; DaveCode will not pass text to it"));
+    }
+    return new Promise((resolve6, reject) => {
+      execFile2(
+        gh,
+        args,
+        {
+          cwd,
+          env: { ...env, GH_PROMPT_DISABLED: "1" },
+          timeout: SLOW_MS,
+          windowsHide: true,
+          encoding: "utf8"
+        },
+        (err, stdout, stderr) => {
+          if (err) {
+            const missing = err.code === "ENOENT";
+            reject(
+              new Error(
+                missing ? "GitHub CLI (gh) is not installed. Install it and run `gh auth login`." : (stderr || err.message).trim()
+              )
+            );
+          } else resolve6(stdout.trim());
+        }
+      );
+    });
   }
-  async save(goal) {
-    await atomicWriteFile(
-      join7(this.goalDir(goal.id), "goal.json"),
-      `${JSON.stringify(goal, null, 2)}
-`
-    );
+  async function commitAll(g, message) {
+    await g.run(["add", "-A"]);
+    if (!await g.hasStagedChanges()) return void 0;
+    await g.run([...await identityArgs(g), "commit", "--quiet", "-m", message]);
+    return (await g.run(["rev-parse", "--short", "HEAD"])).trim();
   }
-  /** The goal, or `undefined` when unknown. Throws when `goal.json` is corrupt. */
-  async load(id) {
-    if (!isGoalId(id)) return void 0;
-    const text = await readFileIfExists(join7(this.goalDir(id), "goal.json"));
-    if (text === void 0) return void 0;
-    return goalSchema.parse(JSON.parse(text));
+  function writeMeta(meta) {
+    mkdirSync8(panesDir, { recursive: true });
+    writeFileSync4(metaFile(meta.id), `${JSON.stringify(meta, null, 2)}
+`);
   }
-  /** Every readable goal, newest first. Corrupt entries are skipped. */
-  async list() {
-    let names;
+  async function removeWorktree(dir) {
     try {
-      names = await readdir3(this.dir);
-    } catch (err) {
-      if (isNodeError(err, "ENOENT")) return [];
-      throw err;
+      await repo.run(["worktree", "remove", "--force", dir]);
+    } catch {
     }
-    const goals = [];
-    for (const name of names.filter(isGoalId)) {
-      try {
-        const goal = await this.load(name);
-        if (goal) goals.push(goal);
-      } catch {
-      }
+    if (existsSync5(dir))
+      rmSync5(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+    try {
+      await repo.run(["worktree", "prune"]);
+    } catch {
     }
-    return goals.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-  }
-  /** Writes a task's markdown artifact and returns its repository-relative path (`/`-separated). */
-  async writeArtifact(goalId, taskId, markdown) {
-    const path10 = join7(this.goalDir(goalId), `${taskId}.md`);
-    await atomicWriteFile(path10, markdown.endsWith("\n") ? markdown : `${markdown}
-`);
-    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;
-    return readFileIfExists(join7(this.goalDir(goalId), `${taskId}.md`));
   }
-};
-var PROJECT_CONTEXT_CHARS = 3e3;
-function createGoalService(engine, opts) {
-  const { brain } = opts;
-  const lock = opts.lock ?? new WorkspaceLock();
-  const store = new GoalStore(brain.root);
-  const codeRunner = new RunnerCodeTasks({
-    engine,
-    brain,
-    lock,
-    ...opts.budgetContext ? { contextExtras: opts.budgetContext } : {},
-    ...opts.executor ? { executor: opts.executor } : {}
-  });
-  const projectContext = async () => {
-    if (!await brain.isInitialised()) return "";
-    const [architecture, state] = await Promise.all([brain.readArchitecture(), brain.readState()]);
-    return [
-      `ARCHITECTURE.md:
-${truncateHead(architecture.trim(), PROJECT_CONTEXT_CHARS)}`,
-      `STATE.md:
-${truncateHead(state.trim(), PROJECT_CONTEXT_CHARS)}`
-    ].join("\n\n");
+  const service = {
+    async list() {
+      await assertRepo();
+      const isolated = isolatedIds().map((id) => target(id)).sort((a, b) => (a.meta?.createdAt ?? "").localeCompare(b.meta?.createdAt ?? ""));
+      return Promise.all([target(MAIN_WORKSPACE_ID), ...isolated].map(describe));
+    },
+    async get(id) {
+      await assertRepo();
+      return describe(target(id));
+    },
+    create(input = {}) {
+      return serial(async () => {
+        const head = await assertRepo();
+        if (isolatedIds().length >= CHANGES_LIMITS.maxWorkspaces) {
+          throw new ChangesError(
+            "limit",
+            `At most ${CHANGES_LIMITS.maxWorkspaces} isolated workspaces per project. Remove one first.`
+          );
+        }
+        const id = randomBytes9(4).toString("hex").slice(0, 6);
+        const dir = path9.join(panesDir, id);
+        const baseBranch = await optional(repo, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
+        const branch = await uniqueBranch(repo, `${PANE_BRANCH_PREFIX}${id}`);
+        mkdirSync8(panesDir, { recursive: true });
+        await repo.run(["worktree", "add", "-b", assertSafeRef(branch), dir, head]);
+        writeMeta({
+          id,
+          label: input.label ?? "Isolated",
+          ...baseBranch ? { baseBranch } : {},
+          baseCommit: head,
+          createdAt: now().toISOString()
+        });
+        return describe(target(id));
+      });
+    },
+    async diff(id, file) {
+      await assertRepo();
+      const t = target(id);
+      const g = gitAt(t.path);
+      const { base, files } = await changedFiles(g, t);
+      let selected = files;
+      if (file !== void 0) {
+        selected = files.filter((f) => f.path === file || f.oldPath === file);
+        if (selected.length === 0) throw new ChangesError("not_found", `"${file}" has no changes`);
+      }
+      const tracked = selected.filter((f) => f.status !== "untracked");
+      let patch = "";
+      if (tracked.length > 0) {
+        const paths = tracked.flatMap((f) => f.oldPath ? [f.oldPath, f.path] : [f.path]);
+        patch = await g.run([
+          "-c",
+          "core.quotepath=false",
+          "diff",
+          "--no-ext-diff",
+          "--no-color",
+          "-M",
+          base,
+          "--",
+          ...file === void 0 ? [] : paths
+        ]);
+      }
+      for (const f of selected) {
+        if (f.status === "untracked") patch += newFilePatch(f.path, readUntracked(t.path, f.path));
+      }
+      const truncated = patch.length > CHANGES_LIMITS.diffMaxLength;
+      return { patch: truncated ? patch.slice(0, CHANGES_LIMITS.diffMaxLength) : patch, truncated };
+    },
+    async suggest(id, input = {}) {
+      const { agent } = suggestSchema.parse(input);
+      await assertRepo();
+      const t = target(id);
+      const workspace = await describe(t);
+      if (workspace.files.length === 0) {
+        throw new ChangesError("nothing_to_commit", "There are no changes to describe.");
+      }
+      const fallback = fallbackSuggestion(workspace.files);
+      if (!agent) return fallback;
+      if (!options.writer) {
+        throw new ChangesError("unavailable", "No agent can write the message on this gateway.");
+      }
+      const { patch } = await service.diff(id);
+      const controller = new AbortController();
+      const result = await options.writer.run({
+        agent,
+        cwd: t.path,
+        prompt: agentPrompt({
+          ...workspace.branch ? { branch: workspace.branch } : {},
+          files: workspace.files,
+          patch
+        }),
+        mode: "plan",
+        signal: controller.signal,
+        timeoutMs: CHANGES_LIMITS.suggestTimeoutMs,
+        onOutput: () => {
+        }
+      });
+      const parsed = result.ok ? parseAgentSuggestion(result.text) : void 0;
+      if (!parsed) {
+        const why = result.ok ? "it did not reply with the expected JSON" : result.error ?? "it failed";
+        throw new ChangesError("unavailable", `${agent} could not write the message: ${why}`);
+      }
+      return { ...parsed, by: agent };
+    },
+    ship(id, input) {
+      const request = shipSchema.parse(input);
+      return serial(async () => {
+        await assertRepo();
+        const t = target(id);
+        const g = gitAt(t.path, true);
+        const steps = [];
+        let branch = await optional(g, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
+        let commit;
+        let prUrl;
+        const wantPush = request.push || request.pr !== void 0;
+        if (!branch && (wantPush || request.pr)) {
+          throw new ChangesError("invalid", "HEAD is detached. Check out a branch first.");
+        }
+        const finish = async (ok) => ({
+          ok,
+          steps,
+          ...commit ? { commit } : {},
+          ...branch ? { branch } : {},
+          ...prUrl ? { prUrl } : {},
+          workspace: await describe(t)
+        });
+        const step = async (phase, work) => {
+          try {
+            steps.push({ phase, ok: true, detail: await work() });
+            return true;
+          } catch (err) {
+            steps.push({ phase, ok: false, detail: short(err) });
+            return false;
+          }
+        };
+        const before = await describe(t);
+        if (request.message && !before.dirty && !wantPush) {
+          throw new ChangesError("nothing_to_commit", "There is nothing to commit.");
+        }
+        if (!request.message && !wantPush) {
+          throw new ChangesError("invalid", "Give a commit message, push or a pull request.");
+        }
+        const base = request.pr?.base ?? (t.isolated ? t.meta?.baseBranch : void 0) ?? (request.pr ? await defaultBranch(g) : void 0);
+        if (request.pr && branch) {
+          const current = branch;
+          const slug = slugify(request.pr.title);
+          if (!t.isolated && current === base) {
+            const ok = await step("branch", async () => {
+              const name = await uniqueBranch(g, `davecode/${slug}`);
+              await g.run(["switch", "--quiet", "-c", assertSafeRef(name)]);
+              branch = name;
+              return `Created ${name} from ${current}`;
+            });
+            if (!ok) return finish(false);
+          } else if (t.isolated && current.startsWith(PANE_BRANCH_PREFIX) && !before.upstream) {
+            const ok = await step("branch", async () => {
+              const name = await uniqueBranch(g, `davecode/${slug}`);
+              await g.run(["branch", "-m", assertSafeRef(current), assertSafeRef(name)]);
+              branch = name;
+              return `Renamed ${current} to ${name}`;
+            });
+            if (!ok) return finish(false);
+          }
+        }
+        if (request.message && before.dirty) {
+          const message = request.message;
+          const ok = await step("commit", async () => {
+            commit = await commitAll(g, message);
+            if (!commit) throw new Error("Nothing was staged.");
+            return `Committed ${commit}`;
+          });
+          if (!ok) return finish(false);
+        }
+        if (wantPush && branch) {
+          const name = branch;
+          const ok = await step("push", async () => {
+            if (!await g.hasRemote()) throw new Error('This repository has no "origin" remote.');
+            await g.run(["push", "--quiet", "--set-upstream", "origin", assertSafeRef(name)]);
+            return `Pushed ${name} to origin`;
+          });
+          if (!ok) return finish(false);
+        }
+        if (request.pr && branch) {
+          const pr = request.pr;
+          const head = branch;
+          const ok = await step("pr", async () => {
+            if (!base) throw new Error("Could not tell which branch the pull request targets.");
+            if (base === head) throw new Error(`The pull request would merge ${head} into itself.`);
+            const args = [
+              "pr",
+              "create",
+              "--base",
+              assertSafeRef(base),
+              "--head",
+              assertSafeRef(head)
+            ];
+            args.push("--title", pr.title, "--body", pr.body || pr.title);
+            if (pr.draft) args.push("--draft");
+            try {
+              const out = await runGh(t.path, args);
+              prUrl = out.split("\n").at(-1)?.trim() || out;
+            } catch (err) {
+              const text = err instanceof Error ? err.message : String(err);
+              if (!/already exists/i.test(text)) throw err;
+              prUrl = await runGh(t.path, ["pr", "view", head, "--json", "url", "--jq", ".url"]);
+            }
+            return prUrl;
+          });
+          if (!ok) return finish(false);
+        }
+        return finish(true);
+      });
+    },
+    merge(id, input = {}) {
+      const { message } = mergeSchema.parse(input);
+      return serial(async () => {
+        await assertRepo();
+        const t = target(id);
+        if (!t.isolated)
+          throw new ChangesError("invalid", "Only an isolated workspace can be merged.");
+        const g = gitAt(t.path, true);
+        const branch = await optional(g, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
+        if (!branch) throw new ChangesError("invalid", "The workspace has no branch checked out.");
+        let state = await describe(t);
+        if (state.dirty) {
+          if (!message) {
+            throw new ChangesError(
+              "dirty",
+              "The workspace has uncommitted changes. Commit them first."
+            );
+          }
+          await commitAll(g, message);
+          state = await describe(t);
+        }
+        if (state.ahead === 0)
+          throw new ChangesError("nothing_to_commit", "There is nothing to merge.");
+        const into = await optional(repo, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
+        if (!into) throw new ChangesError("invalid", "The project checkout is on a detached HEAD.");
+        if (samePath(t.path, projectDir))
+          throw new ChangesError("invalid", "Cannot merge into itself.");
+        const main = gitAt(projectDir, true);
+        try {
+          await main.run([
+            ...await identityArgs(main),
+            "merge",
+            "--no-ff",
+            "--no-edit",
+            "-m",
+            `Merge ${t.label} (${branch}) into ${into}`,
+            assertSafeRef(branch)
+          ]);
+        } catch (err) {
+          const conflicts = nul(
+            await optional(main, ["diff", "--name-only", "-z", "--diff-filter=U"]) ?? ""
+          );
+          await main.abortMerge();
+          throw new ChangesError(
+            "conflict",
+            conflicts.length > 0 ? `The merge conflicts in ${conflicts.join(", ")}. Nothing was changed.` : `The merge failed: ${short(err)}`
+          );
+        }
+        return describe(target(MAIN_WORKSPACE_ID));
+      });
+    },
+    remove(id, input = {}) {
+      const { deleteBranch } = removeSchema.parse(input);
+      return serial(async () => {
+        const t = target(id);
+        if (!t.isolated)
+          throw new ChangesError("invalid", "The project checkout cannot be removed.");
+        const branch = await optional(gitAt(t.path), [
+          "symbolic-ref",
+          "--quiet",
+          "--short",
+          "HEAD"
+        ]);
+        await removeWorktree(t.path);
+        rmSync5(metaFile(id), { force: true });
+        if (deleteBranch && branch) {
+          try {
+            await repo.run(["branch", "-D", assertSafeRef(branch)]);
+          } catch {
+          }
+        }
+      });
+    }
   };
-  const orchestrator = new GoalOrchestrator({
-    router: engine.router,
-    store,
-    events: engine.events,
-    config: engine.config.goal,
-    codeRunner,
-    projectContext,
-    ...opts.budgetContext ? { budgetContext: opts.budgetContext } : {}
-  });
-  return new GoalService({ orchestrator, store, lock });
+  return service;
 }
-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"
+var DEFAULT_ROLES = [
+  {
+    id: "planner",
+    description: "Breaks the objective into a plan, defines milestones and success criteria.",
+    kind: "artifact"
   },
-  codex: {
-    label: "Codex",
-    binary: "codex",
-    provider: "codex-cli",
-    signIn: "run `codex login` in a terminal"
+  {
+    id: "researcher",
+    description: "Analyses markets, users, competitors and options from its own knowledge and the workspace; cannot browse the web.",
+    kind: "artifact"
   },
-  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);
+  {
+    id: "implementer",
+    description: "Writes and changes code in the repository (handed to the autonomous runner).",
+    kind: "code"
+  },
+  {
+    id: "reviewer",
+    description: "Critically reviews other outputs for gaps, risks and quality.",
+    kind: "artifact"
+  },
+  {
+    id: "writer",
+    description: "Writes positioning, marketing copy, landing-page text, documentation and drafts of messages.",
+    kind: "artifact"
   }
-}
-function agentStdin(agent, mode, prompt) {
-  if (agent === "agy") {
-    const content = mode === "plan" ? `${AGY_PLAN_NOTE}
-
-${prompt}` : prompt;
-    return `${JSON.stringify({ event: "user", message: { content } })}
-`;
+];
+function resolveRoles(config) {
+  const roles = new Map(DEFAULT_ROLES.map((r) => [r.id, { ...r }]));
+  for (const [id, override] of Object.entries(config.roles)) {
+    const base = roles.get(id);
+    const role = {
+      id,
+      description: override.description ?? base?.description ?? id,
+      kind: override.kind ?? base?.kind ?? "artifact"
+    };
+    if (override.route) role.route = override.route;
+    const instructions = override.instructions ?? base?.instructions;
+    if (instructions) role.instructions = instructions;
+    roles.set(id, role);
   }
-  if (agent === "claude" && prompt.trimStart().startsWith("/")) return `Task:
-${prompt}`;
-  return prompt;
+  return [...roles.values()];
 }
-function abortError() {
-  const err = new Error("The agent run was aborted");
-  err.name = "AbortError";
-  return err;
+function publicRoles(roles) {
+  return roles.map(
+    ({ id, description, route }) => route ? { id, description, route } : { id, description }
+  );
 }
-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]"
-  ]
+var OUTBOUND = [
+  /\b(send|sending|email|e-mail|emailing|mail out)\b/i,
+  /\b(tweet|dm|direct message|share on)\b/i,
+  /\b(post|publish)\b[^.\n]{0,60}\b(on|to)\b/i,
+  /\b(pay|purchase|buy|checkout|subscribe to|sign up|signup|register (for|on|at))\b/i,
+  /\b(outreach|cold[- ]?(call|email)|contact (the|our|potential|prospects?|customers?|leads?))\b/i,
+  /\b(launch (the )?ads?|run (the )?ads?|ad campaign|deploy to production|go live)\b/i
 ];
-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`;
+var OPERATIONAL = [
+  /\b(deploy|release|publish)\b[^.\n]*\b(production|prod|npm|app store|play store|live)\b/i,
+  /\b(go live|pay|purchase|buy|checkout)\b/i,
+  /\b(send|email|e-mail|message)\b[^.\n]*\b(customers?|users?|leads?|prospects?|subscribers?|mailing list|newsletter)\b/i,
+  /\b(post|tweet|publish)\b[^.\n]*\b(twitter|x\.com|linkedin|facebook|instagram|reddit|hacker news|product hunt)\b/i
+];
+function firstMatch(patterns, text) {
+  for (const pattern of patterns) {
+    const match = pattern.exec(text);
+    if (match) return match[0];
+  }
+  return void 0;
 }
-function shortError(text) {
-  return clip(scrubSecrets(text), MAX_ERROR);
+function outboundAction(text) {
+  return firstMatch(OUTBOUND, text);
 }
-function formatDuration(ms) {
-  if (ms >= 6e4) return `${Math.round(ms / 6e4)} min`;
-  return `${Math.max(1, Math.ceil(ms / 1e3))} s`;
+var DRAFT_NOTICE = "DaveCode never performs outbound actions (emails, posts, payments, sign-ups, deployments). Produce a ready-to-use DRAFT for a human to review and execute.";
+function applySafetyGuard(task) {
+  const text = `${task.title}
+${task.description ?? ""}`;
+  const action = task.kind === "code" ? firstMatch(OPERATIONAL, text) : firstMatch(OUTBOUND, text);
+  if (!action) return task;
+  const title = /^draft\b/i.test(task.title) ? task.title : `Draft: ${task.title}`;
+  const description = [task.description?.trim(), DRAFT_NOTICE].filter(Boolean).join("\n\n");
+  return { ...task, kind: "artifact", title: title.slice(0, 300), description };
 }
-function tail(text, max = 400) {
-  const t = text.trim();
-  return t.length <= max ? t : t.slice(t.length - max);
+var plannedTaskSchema = z14.object({
+  id: z14.string().min(1).max(80),
+  title: z14.string().trim().min(1).max(300),
+  description: z14.string().max(8e3).optional(),
+  role: z14.string().min(1).max(40),
+  kind: z14.enum(["code", "artifact"]).optional(),
+  dependsOn: z14.array(z14.string().min(1)).max(50).default([]),
+  acceptance: z14.array(z14.string().min(1).max(1e3)).max(20).optional()
+});
+var planSchema = z14.object({
+  summary: z14.string().max(4e3).optional(),
+  tasks: z14.array(plannedTaskSchema).min(1).max(100)
+});
+var reviewSchema = z14.object({
+  /** The objective is achieved as far as DaveCode can take it. */
+  done: z14.boolean(),
+  summary: z14.string().max(8e3),
+  /** Ids of FAILED tasks worth another attempt. */
+  retry: z14.array(z14.string()).max(50).default([]),
+  /** New tasks for the next round. */
+  tasks: z14.array(plannedTaskSchema).max(50).default([])
+});
+var TASK_ID = /^[a-z0-9]+(?:[-_.][a-z0-9]+)*$/;
+function sanitizeTaskId(raw) {
+  const id = raw.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60).replace(/-+$/g, "");
+  return TASK_ID.test(id) ? id : "task";
 }
-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;
-      }
-    }
+function normalizeTasks(planned, opts) {
+  const roleById = new Map(opts.roles.map((r) => [r.id, r]));
+  const taken = new Set(opts.existing.map((t) => t.id));
+  const idMap = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const p of planned.slice(0, Math.max(0, opts.room))) {
+    let id = sanitizeTaskId(p.id);
+    for (let n = 2; taken.has(id); n++) id = `${sanitizeTaskId(p.id)}-${n}`;
+    taken.add(id);
+    idMap.set(p.id, id);
+    let role = roleById.get(p.role.toLowerCase());
+    const requested = p.kind ?? role?.kind ?? "artifact";
+    if (!role)
+      role = roleById.get(requested === "code" ? "implementer" : "writer") ?? opts.roles[0];
+    const kind = requested === "code" && opts.codeTasks ? "code" : "artifact";
+    const task = {
+      id,
+      title: p.title,
+      role: role?.id ?? "writer",
+      kind,
+      status: "PENDING",
+      dependsOn: p.dependsOn,
+      round: opts.round,
+      attempts: 0
+    };
+    const description = requested === "code" && kind === "artifact" ? [
+      p.description,
+      "Code tasks cannot run here: write a precise implementation plan instead."
+    ].filter(Boolean).join("\n\n") : p.description;
+    if (description) task.description = description;
+    if (p.acceptance?.length) task.acceptance = p.acceptance;
+    out.push(applySafetyGuard(task));
   }
-  return clip(scrubSecrets(hint ? `${name} ${hint}` : name), MAX_TOOL_LINE);
+  const known = /* @__PURE__ */ new Set([...opts.existing.map((t) => t.id), ...out.map((t) => t.id)]);
+  for (const task of out) {
+    task.dependsOn = [
+      ...new Set(task.dependsOn.map((d) => idMap.get(d) ?? sanitizeTaskId(d)))
+    ].filter((d) => d !== task.id && known.has(d));
+  }
+  for (; ; ) {
+    const graph = {
+      version: 1,
+      tasks: [...opts.existing, ...out].map((t) => ({
+        id: t.id,
+        title: t.title,
+        status: t.status,
+        dependsOn: t.dependsOn
+      }))
+    };
+    const cycle = findCycles(graph)[0];
+    if (!cycle) break;
+    const from = cycle[cycle.length - 2];
+    const to = cycle[cycle.length - 1];
+    const task = out.find((t) => t.id === from);
+    if (!task) break;
+    task.dependsOn = task.dependsOn.filter((d) => d !== to);
+  }
+  return out;
 }
-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;
-      }
-    }
-  };
+var SAFETY_RULES = `Hard rules (non-negotiable):
+- You run inside DaveCode with no internet access and no ability to contact anyone.
+- Never send emails or messages, post or publish anything, make payments or purchases, sign up for services, or deploy. When such a step is useful, produce a DRAFT for a human to review and execute.
+- Never invent credentials, personal data or facts presented as verified; label assumptions and estimates clearly.
+- Stay within the objective; prefer concrete, actionable outputs.`;
+function roleList(roles) {
+  return roles.map((r) => `- ${r.id} (${r.kind}): ${r.description}`).join("\n");
 }
-function codexErrorText(value) {
-  if (typeof value === "string") return value;
-  if (isRecord(value)) return asString(value.message) ?? JSON.stringify(value);
-  return void 0;
+function plannerPrompt(roles, codeTasks) {
+  return `You are the planner of a small team of AI agents working toward one objective. Decompose the objective into a dependency graph of concrete tasks and assign each task to one role.
+
+Roles:
+${roleList(roles)}
+
+Task kinds:
+- "artifact": the role writes one markdown document (analysis, plan, copy, checklist, draft).
+- "code": the implementer changes the repository; an autonomous runner branches, runs the quality gates and merges.${codeTasks ? "" : "\n  Code tasks are NOT available in this workspace: plan artifact tasks only."}
+
+${SAFETY_RULES}
+
+Plan at most the number of tasks you are allowed, smallest useful set first. Ids are short lowercase kebab-case. Use dependsOn so later tasks build on earlier outputs.
+
+Respond with ONLY a JSON object, no prose and no code fences:
+{"summary": "one paragraph plan", "tasks": [{"id": "market-research", "title": "...", "description": "...", "role": "researcher", "kind": "artifact", "dependsOn": [], "acceptance": ["..."]}]}`;
 }
-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);
+var REVIEWER_PROMPT = `You are the reviewer of a team of AI agents working toward one objective. Judge the results so far against the objective.
+
+${SAFETY_RULES}
+
+Decide:
+- "done": true when the objective is achieved as far as an offline team can take it (remaining steps are outbound actions a human must do from the drafts).
+- otherwise propose the next round: "retry" lists FAILED task ids worth another attempt, "tasks" lists new tasks (same shape as the planner's, dependsOn may reference existing ids).
+
+Respond with ONLY a JSON object, no prose and no code fences:
+{"done": false, "summary": "progress, gaps and what a human must do next", "retry": [], "tasks": []}`;
+function roleSystemPrompt(role) {
+  return [
+    `You are the ${role.id} of a small team of AI agents. ${role.description}`,
+    SAFETY_RULES,
+    "Write your deliverable as a single, well-structured markdown document. Do not wrap it in code fences. Start with a level-1 heading.",
+    role.instructions?.trim()
+  ].filter(Boolean).join("\n\n");
+}
+var MeteredExecutor = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
+  inner;
+  tokens = 0;
+  get name() {
+    return this.inner.name;
+  }
+  createSession(task) {
+    const session = this.inner.createSession(task);
+    return {
+      run: async (opts) => {
+        const result = await session.run(opts);
+        this.tokens += Math.max(0, result.tokens);
+        return result;
+      }
+    };
+  }
+};
+var MIN_TASK_TOKENS = 1e4;
+var RunnerCodeTasks = class {
+  constructor(options) {
+    this.options = options;
+    this.owner = options.owner ?? "goal";
+  }
+  options;
+  owner;
+  async available() {
+    const { brain, engine } = this.options;
+    const git = new Git(brain.root);
+    if (!await git.isRepo())
+      return { ok: false, reason: `${brain.root} is not a git repository` };
+    if (!await brain.isInitialised()) {
+      return { ok: false, reason: "the project brain is missing (run davecode init)" };
     }
-    case "mcp_tool_call": {
-      const name = [asString(item.server), asString(item.tool)].filter(Boolean).join(".");
-      return toolLine(name || "MCP tool", void 0, cwd);
+    const base = engine.config.runner.baseBranch;
+    if (!await git.branchExists(base)) {
+      return { ok: false, reason: `base branch "${base}" does not exist` };
     }
-    case "web_search":
-      return toolLine("Search", { query: asString(item.query) ?? "" }, cwd);
-    default:
-      return toolLine(type, item, cwd);
+    if ((await git.status({ ignoreBrain: true })).length > 0) {
+      return { ok: false, reason: "the working tree has uncommitted changes" };
+    }
+    return { ok: true };
   }
-}
-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) });
-        }
-      }
+  async run(task, opts) {
+    const { brain, engine } = this.options;
+    const runnerTaskId = sanitizeTaskId(`goal-${opts.goal.id.slice(-6)}-${task.id}`);
+    const graph = await brain.readGraph();
+    const existing = graph.tasks.find((t) => t.id === runnerTaskId);
+    if (existing?.status === "SUCCESS") {
+      return { ok: true, summary: existing.notes ?? "already done", tokens: 0, runnerTaskId };
     }
-  };
+    if (!existing) {
+      await brain.createTask({
+        id: runnerTaskId,
+        title: task.title,
+        description: [
+          task.description,
+          `Part of DaveCode goal ${opts.goal.id}: ${opts.goal.objective}`
+        ].filter(Boolean).join("\n\n"),
+        ...task.acceptance?.length ? { acceptance: task.acceptance } : {}
+      });
+    } else if (existing.status !== "PENDING") {
+      await brain.setTaskStatus(runnerTaskId, "PENDING", { notes: "retried by goal mode" });
+    }
+    const base = engine.config.runner;
+    const config = {
+      ...base,
+      maxTaskTokens: Math.max(MIN_TASK_TOKENS, Math.min(base.maxTaskTokens, opts.maxTokens))
+    };
+    const metered = new MeteredExecutor(this.options.executor ?? createExecutor(engine, config));
+    const runner = this.options.makeRunner?.(config, metered) ?? createRunner(engine, {
+      brain,
+      config,
+      executor: metered,
+      lock: { lock: this.options.lock, owner: this.owner },
+      ...this.options.contextExtras ? { contextExtras: this.options.contextExtras } : {}
+    });
+    const onAbort = () => void runner.stop();
+    opts.signal.addEventListener("abort", onAbort, { once: true });
+    try {
+      const result = await runner.runOnce({ taskId: runnerTaskId });
+      return {
+        ok: result.outcome === "success",
+        summary: result.summary ?? result.error ?? result.outcome,
+        tokens: metered.tokens,
+        runnerTaskId,
+        ...result.outcome === "stopped" ? { stopped: true } : {}
+      };
+    } catch (err) {
+      if (!(err instanceof RunnerError)) throw err;
+      return { ok: false, summary: err.message, tokens: metered.tokens, runnerTaskId };
+    } finally {
+      opts.signal.removeEventListener("abort", onAbort);
+    }
+  }
+};
+var TERMINAL = /* @__PURE__ */ new Set([
+  "planned",
+  "succeeded",
+  "failed",
+  "cancelled",
+  "budget_exhausted"
+]);
+function isTerminalGoal(goal) {
+  return TERMINAL.has(goal.status);
 }
-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;
+var Cancelled = class extends Error {
+};
+var OutOfBudget = class extends Error {
+};
+var MAX_DEP_CHARS = 6e3;
+var MAX_DEPS_TOTAL = 2e4;
+var MAX_REVIEW_EXCERPT = 1500;
+var MAX_TOOL_ROUNDS = 6;
+var GoalOrchestrator = class {
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.tools = new WorkspaceTools({ root: options.store.root, readOnly: true });
+  }
+  options;
+  now;
+  tools;
+  /** A fresh goal (not yet persisted) with limits clamped to the config. */
+  create(input) {
+    const cfg = this.options.config;
+    const stamp = this.now().toISOString();
+    const goal = {
+      id: newId2("goal", 6),
+      objective: input.objective.trim(),
+      status: "planning",
+      round: 0,
+      limits: {
+        maxRounds: Math.min(input.maxRounds ?? cfg.maxRounds, cfg.maxRounds),
+        maxTasks: Math.min(input.maxTasks ?? cfg.maxTasks, cfg.maxTasks),
+        maxTokens: Math.min(input.maxTokens ?? cfg.maxTokens, cfg.maxTokens),
+        tokensUsed: 0
+      },
+      roles: publicRoles(resolveRoles(cfg)),
+      tasks: [],
+      createdAt: stamp,
+      updatedAt: stamp
+    };
+    if (input.dryRun) goal.dryRun = true;
+    return goal;
+  }
+  /** Runs `goal` to a terminal status. Never throws: failures end up in `status`/`lastError`. */
+  async run(goal, signal) {
+    const cfg = this.options.config;
+    const roles = resolveRoles(cfg);
+    try {
+      const code = await this.codeAvailability();
+      if (!code.ok) this.log(goal, "info", `code tasks disabled: ${code.reason}`);
+      if (goal.round === 0 || goal.tasks.length === 0) {
+        goal.round = 1;
+        await this.update(goal, { status: "planning" });
+        this.log(goal, "info", `planning: ${goal.objective}`, "planner");
+        const plan = await this.plan(goal, roles, code.ok, signal);
+        goal.tasks = normalizeTasks(plan.tasks, {
+          existing: [],
+          roles,
+          round: 1,
+          room: goal.limits.maxTasks,
+          codeTasks: code.ok
+        });
+        if (plan.summary) goal.summary = plan.summary;
+        this.log(goal, "info", `planned ${goal.tasks.length} task(s)`, "planner");
+        if (goal.dryRun) return await this.finish(goal, "planned");
+      } else {
+        this.log(goal, "info", `executing planned goal (${goal.tasks.length} task(s))`, "planner");
       }
-      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;
+      for (; ; ) {
+        await this.update(goal, { status: "running" });
+        await this.executeReady(goal, roles, signal);
+        await this.update(goal, { status: "reviewing" });
+        this.log(goal, "info", `reviewing round ${goal.round}`, "reviewer");
+        const review = await this.review(goal, roles, signal);
+        goal.summary = review.summary;
+        if (review.done) return await this.finish(goal, "succeeded");
+        if (goal.round >= goal.limits.maxRounds) {
+          goal.lastError = `reached ${goal.limits.maxRounds} round(s) without completing the objective`;
+          return await this.finish(goal, "failed");
         }
-        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) });
+        const retried = this.applyRetries(goal, review.retry);
+        const added = normalizeTasks(review.tasks, {
+          existing: goal.tasks,
+          roles,
+          round: goal.round + 1,
+          room: goal.limits.maxTasks - goal.tasks.length,
+          codeTasks: code.ok
+        });
+        if (retried === 0 && added.length === 0) {
+          goal.lastError = goal.tasks.length >= goal.limits.maxTasks ? `reached the cap of ${goal.limits.maxTasks} task(s) without completing the objective` : "the reviewer proposed no further work but the objective is not done";
+          return await this.finish(goal, "failed");
         }
-        return;
+        goal.tasks.push(...added);
+        goal.round++;
+        this.log(
+          goal,
+          "info",
+          `round ${goal.round}: ${added.length} new task(s), ${retried} retried`,
+          "reviewer"
+        );
       }
-      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();
+    } catch (err) {
+      for (const task of goal.tasks) if (task.status === "IN_PROGRESS") task.status = "PENDING";
+      delete goal.activeTaskId;
+      if (err instanceof Cancelled || signal.aborted) return await this.finish(goal, "cancelled");
+      if (err instanceof OutOfBudget) {
+        goal.lastError = err.message;
+        return await this.finish(goal, "budget_exhausted");
       }
+      goal.lastError = err instanceof Error ? err.message : String(err);
+      this.log(goal, "error", goal.lastError);
+      return await this.finish(goal, "failed");
+    }
+  }
+  // -- phases -----------------------------------------------------------------
+  async codeAvailability() {
+    if (!this.options.config.codeTasks) return { ok: false, reason: "goal.codeTasks is off" };
+    if (!this.options.codeRunner) return { ok: false, reason: "no project runner available" };
+    try {
+      return await this.options.codeRunner.available();
+    } catch (err) {
+      return { ok: false, reason: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async plan(goal, roles, codeTasks, signal) {
+    const user = [
+      `OBJECTIVE:
+${goal.objective}`,
+      `You may plan at most ${goal.limits.maxTasks} task(s) in total; the team has ${goal.limits.maxRounds} round(s) of plan \u2192 execute \u2192 review.`,
+      await this.sharedContext()
+    ].filter(Boolean).join("\n\n");
+    return this.askJson(
+      planSchema,
+      goal,
+      this.roleFor(roles, "planner"),
+      plannerPrompt(roles, codeTasks),
+      user,
+      signal
+    );
+  }
+  async review(goal, roles, signal) {
+    const lines2 = [];
+    for (const task of goal.tasks) {
+      lines2.push(
+        `- [${task.status}] ${task.id} (${task.role}, ${task.kind}, round ${task.round}, ${task.attempts} attempt(s)): ${task.title}`
+      );
+      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)
+          lines2.push(`  output excerpt:
+${indent(truncateHead(text, MAX_REVIEW_EXCERPT))}`);
+      }
+    }
+    const user = [
+      `OBJECTIVE:
+${goal.objective}`,
+      `Round ${goal.round} of ${goal.limits.maxRounds}. Room for ${Math.max(0, goal.limits.maxTasks - goal.tasks.length)} more task(s).`,
+      `TASKS:
+${lines2.join("\n")}`,
+      await this.sharedContext()
+    ].filter(Boolean).join("\n\n");
+    return this.askJson(
+      reviewSchema,
+      goal,
+      this.roleFor(roles, "reviewer"),
+      REVIEWER_PROMPT,
+      user,
+      signal
+    );
+  }
+  /** Runs ready tasks until none is left; failed tasks are retried up to `maxTaskAttempts`. */
+  async executeReady(goal, roles, signal) {
+    for (; ; ) {
+      const task = readyGoalTasks(goal)[0];
+      if (!task) return;
+      this.checkpoint(goal, signal);
+      task.attempts++;
+      task.status = "IN_PROGRESS";
+      await this.update(goal, { activeTaskId: task.id });
+      this.log(goal, "info", `${task.title} (attempt ${task.attempts})`, task.role, task.id);
+      try {
+        if (task.kind === "code") await this.runCodeTask(goal, task, signal);
+        else await this.runArtifactTask(goal, task, this.roleFor(roles, task.role), signal);
+        const outcome = task.status;
+        this.log(
+          goal,
+          outcome === "SUCCESS" ? "info" : "warn",
+          `${task.id}: ${outcome}`,
+          task.role,
+          task.id
+        );
+      } catch (err) {
+        if (err instanceof Cancelled || err instanceof OutOfBudget || signal.aborted) throw err;
+        if (err instanceof RouterError && (err.code === "no_capacity" || err.code === "rate_limited")) {
+          throw new OutOfBudget(`no account has capacity left (${err.message})`);
+        }
+        task.status = "FAILED";
+        task.notes = truncateHead(err instanceof Error ? err.message : String(err), 2e3);
+        this.log(goal, "warn", `${task.id} failed: ${task.notes}`, task.role, task.id);
+      }
+      if (task.status === "FAILED" && task.attempts < this.options.config.maxTaskAttempts) {
+        task.status = "PENDING";
+      }
+      delete goal.activeTaskId;
+      await this.update(goal, {});
+    }
+  }
+  async runArtifactTask(goal, task, role, signal) {
+    const parts = [`OBJECTIVE OF THE TEAM:
+${goal.objective}`, `YOUR TASK: ${task.title}`];
+    if (task.description) parts.push(task.description);
+    if (task.acceptance?.length) {
+      parts.push(`Acceptance criteria:
+${task.acceptance.map((c) => `- ${c}`).join("\n")}`);
+    }
+    let budget = MAX_DEPS_TOTAL;
+    for (const depId of task.dependsOn) {
+      const dep = goal.tasks.find((t) => t.id === depId);
+      if (!dep || budget <= 0) continue;
+      const text = dep.artifact ? await this.options.store.readArtifact(goal.id, dep.id) : dep.notes;
+      if (!text) continue;
+      const excerpt = truncateHead(text, Math.min(MAX_DEP_CHARS, budget));
+      budget -= excerpt.length;
+      parts.push(`OUTPUT OF ${dep.id} (${dep.role}): ${dep.title}
+${excerpt}`);
+    }
+    const shared = await this.sharedContext(false);
+    if (shared) parts.push(shared);
+    const reply = (await this.ask(goal, role, roleSystemPrompt(role), parts.join("\n\n"), signal)).trim();
+    if (!reply) throw new Error("the agent returned an empty reply");
+    task.artifact = await this.options.store.writeArtifact(goal.id, task.id, stripFence(reply));
+    task.status = "SUCCESS";
+    task.notes = `Wrote ${task.artifact}`;
+  }
+  async runCodeTask(goal, task, signal) {
+    const runner = this.options.codeRunner;
+    if (!runner) throw new Error("no project runner available for code tasks");
+    const result = await runner.run(task, {
+      goal,
+      maxTokens: goal.limits.maxTokens - goal.limits.tokensUsed,
+      signal
+    });
+    this.addTokens(goal, result.tokens);
+    if (result.runnerTaskId) task.runnerTaskId = result.runnerTaskId;
+    if (result.stopped || signal.aborted) throw new Cancelled();
+    task.status = result.ok ? "SUCCESS" : "FAILED";
+    task.notes = truncateHead(result.summary || (result.ok ? "done" : "failed"), 2e3);
+  }
+  applyRetries(goal, ids) {
+    let count = 0;
+    for (const id of new Set(ids)) {
+      const task = goal.tasks.find((t) => t.id === id);
+      if (task?.status !== "FAILED") continue;
+      task.status = "PENDING";
+      task.attempts = 0;
+      count++;
+    }
+    return count;
+  }
+  // -- model calls ------------------------------------------------------------
+  roleFor(roles, id) {
+    return roles.find((r) => r.id === id) ?? { id, description: id, kind: "artifact" };
+  }
+  async ask(goal, role, system, user, signal) {
+    const model = routeModel(role.route ?? this.options.config.route);
+    const messages = [
+      { role: "system", content: system },
+      { role: "user", content: user }
+    ];
+    let attachTools = this.options.readTools === true;
+    for (let round = 0; round <= MAX_TOOL_ROUNDS; round++) {
+      this.checkpoint(goal, signal);
+      const allowTools = attachTools && round < MAX_TOOL_ROUNDS;
+      let completion;
+      try {
+        ({ completion } = await this.options.router.complete(
+          {
+            model,
+            messages,
+            ...allowTools ? { tools: [...READ_ONLY_TOOL_DEFINITIONS] } : {}
+          },
+          { signal }
+        ));
+      } catch (err) {
+        if (allowTools && err instanceof RouterError && err.code === "no_available_account") {
+          attachTools = false;
+          ({ completion } = await this.options.router.complete({ model, messages }, { signal }));
+        } else {
+          throw err;
+        }
+      }
+      const message = completion.choices[0]?.message;
+      const content = message?.content;
+      const text = typeof content === "string" ? content : "";
+      const usage = completion.usage;
+      this.addTokens(
+        goal,
+        usage && usage.prompt_tokens + usage.completion_tokens > 0 ? usage.prompt_tokens + usage.completion_tokens : countTextTokens(system) + countTextTokens(user) + countTextTokens(text)
+      );
+      const calls = message?.tool_calls ?? [];
+      if (calls.length === 0 || round === MAX_TOOL_ROUNDS) return text;
+      messages.push({ role: "assistant", content: content ?? null, tool_calls: calls });
+      for (const call of calls) {
+        this.log(goal, "debug", `tool ${call.function.name}`, role.id, goal.activeTaskId);
+        const outcome = await this.tools.call(call.function.name, call.function.arguments, signal);
+        messages.push({
+          role: "tool",
+          tool_call_id: call.id,
+          name: call.function.name,
+          content: outcome.output
+        });
+      }
+    }
+    return "";
+  }
+  /** Asks for a JSON reply matching `schema`; one corrective retry on malformed output. */
+  async askJson(schema, goal, role, system, user, signal) {
+    let problem = "";
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const prompt = attempt === 0 ? user : `${user}
+
+Your previous reply was rejected (${problem}). Respond with ONLY the JSON object in the required shape.`;
+      const reply = await this.ask(goal, role, system, prompt, signal);
+      try {
+        const parsed = schema.safeParse(extractJsonObject(reply));
+        if (parsed.success) return parsed.data;
+        problem = parsed.error.issues.slice(0, 3).map((i) => `${i.path.join(".") || "reply"}: ${i.message}`).join("; ");
+      } catch (err) {
+        problem = err instanceof Error ? err.message : String(err);
+      }
+      this.log(goal, "warn", `invalid JSON from the ${role.id}: ${problem}`, role.id);
+    }
+    throw new Error(`the ${role.id} did not return valid JSON (${problem})`);
+  }
+  async sharedContext(includeProject = true) {
+    const parts = [];
+    if (includeProject && this.options.projectContext) {
+      const project = (await this.options.projectContext()).trim();
+      if (project) parts.push(`PROJECT CONTEXT:
+${project}`);
+    }
+    if (this.options.budgetContext) {
+      const budget = (await this.options.budgetContext()).trim();
+      if (budget) parts.push(budget);
+    }
+    return parts.join("\n\n");
+  }
+  // -- bookkeeping ------------------------------------------------------------
+  checkpoint(goal, signal) {
+    if (signal.aborted) throw new Cancelled();
+    if (goal.limits.tokensUsed >= goal.limits.maxTokens) {
+      throw new OutOfBudget(
+        `token budget exhausted (${goal.limits.tokensUsed}/${goal.limits.maxTokens})`
+      );
+    }
+  }
+  addTokens(goal, tokens2) {
+    if (Number.isFinite(tokens2) && tokens2 > 0) goal.limits.tokensUsed += Math.round(tokens2);
+  }
+  async update(goal, patch) {
+    Object.assign(goal, patch);
+    goal.updatedAt = this.now().toISOString();
+    await this.options.store.save(goal);
+    this.options.events.emit({ type: "goal.updated", goal: structuredClone(goal) });
+  }
+  async finish(goal, status) {
+    delete goal.activeTaskId;
+    goal.finishedAt = this.now().toISOString();
+    await this.update(goal, { status });
+    this.log(
+      goal,
+      status === "succeeded" || status === "planned" ? "info" : "warn",
+      `goal ${status}${goal.lastError ? `: ${goal.lastError}` : ""} (${goal.limits.tokensUsed} tokens)`
+    );
+    return goal;
+  }
+  log(goal, level, message, role, taskId) {
+    this.options.events.emit({
+      type: "goal.log",
+      goalId: goal.id,
+      level,
+      message,
+      ...role ? { role } : {},
+      ...taskId ? { taskId } : {}
+    });
+  }
+};
+function readyGoalTasks(goal) {
+  const status = new Map(goal.tasks.map((t) => [t.id, t.status]));
+  return goal.tasks.filter(
+    (t) => t.status === "PENDING" && t.dependsOn.every((d) => status.get(d) === "SUCCESS")
+  );
+}
+function indent(text) {
+  return text.split("\n").map((l) => `    ${l}`).join("\n");
+}
+function stripFence(text) {
+  const match = /^```(?:markdown|md)?\s*\n([\s\S]*?)\n```\s*$/i.exec(text);
+  return match?.[1] ?? text;
+}
+var GoalError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "GoalError";
+    this.statusCode = code === "not_found" ? 404 : code === "invalid" ? 400 : 409;
+  }
+  code;
+  /** HTTP status hint for the gateway. */
+  statusCode;
+};
+var GoalService = class {
+  constructor(options) {
+    this.options = options;
+    this.owner = options.owner ?? "goal";
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  options;
+  active;
+  owner;
+  now;
+  get activeGoalId() {
+    return this.active?.goal.id;
+  }
+  /** Validates, persists and starts a goal in the background. Resolves with its initial state. */
+  async start(input) {
+    if (!input.objective.trim()) throw new GoalError("invalid", "the objective is empty");
+    if (this.active) {
+      throw new GoalError("busy", `goal ${this.active.goal.id} is still running; cancel it first`);
+    }
+    const lock = input.dryRun ? void 0 : this.options.lock;
+    if (lock && !lock.acquire(this.owner)) {
+      throw new GoalError(
+        "busy",
+        `the working tree is busy (${lock.holder ?? "another task"} is running)`
+      );
+    }
+    try {
+      const goal = this.options.orchestrator.create(input);
+      await this.options.store.save(goal);
+      this.launch(goal, lock);
+      return structuredClone(goal);
+    } catch (err) {
+      lock?.release(this.owner);
+      throw err;
+    }
+  }
+  /**
+   * Executes a `planned` (dry-run) goal in the background without re-planning round 1.
+   * Resolves with the updated goal (`status: 'running'`).
+   */
+  async execute(id) {
+    if (this.active) {
+      throw new GoalError("busy", `goal ${this.active.goal.id} is still running; cancel it first`);
+    }
+    const goal = await this.options.store.load(id);
+    if (!goal) throw new GoalError("not_found", `unknown goal "${id}"`);
+    if (goal.status !== "planned") {
+      throw new GoalError(
+        "invalid",
+        `goal "${id}" is ${goal.status}; only a planned goal can be executed`
+      );
+    }
+    const lock = this.options.lock;
+    if (lock && !lock.acquire(this.owner)) {
+      throw new GoalError(
+        "busy",
+        `the working tree is busy (${lock.holder ?? "another task"} is running)`
+      );
+    }
+    try {
+      delete goal.dryRun;
+      delete goal.finishedAt;
+      delete goal.lastError;
+      goal.status = "running";
+      goal.updatedAt = this.now().toISOString();
+      await this.options.store.save(goal);
+      this.launch(goal, lock);
+      return structuredClone(goal);
+    } catch (err) {
+      lock?.release(this.owner);
+      throw err;
+    }
+  }
+  /** Reads the markdown artifact produced by `taskId` in goal `id`. */
+  async readArtifact(id, taskId) {
+    const goal = await this.get(id);
+    if (!goal) throw new GoalError("not_found", `unknown goal "${id}"`);
+    const task = goal.tasks.find((t) => t.id === taskId);
+    if (!task?.artifact) {
+      throw new GoalError("not_found", `task "${taskId}" has no artifact in goal "${id}"`);
+    }
+    const content = await this.options.store.readArtifact(id, taskId);
+    if (content === void 0) {
+      throw new GoalError("not_found", `artifact file for task "${taskId}" was not found`);
+    }
+    return { taskId: task.id, path: task.artifact, content };
+  }
+  launch(goal, lock) {
+    const controller = new AbortController();
+    const done = this.options.orchestrator.run(goal, controller.signal).catch((err) => {
+      goal.status = "failed";
+      goal.lastError = err instanceof Error ? err.message : String(err);
+      return goal;
+    }).finally(() => {
+      if (this.active?.goal === goal) this.active = void 0;
+      lock?.release(this.owner);
+    });
+    this.active = { goal, controller, done };
+  }
+  async get(id) {
+    if (this.active?.goal.id === id) return structuredClone(this.active.goal);
+    return this.options.store.load(id);
+  }
+  /** Every goal of the workspace, newest first. */
+  async list() {
+    const stored = await this.options.store.list();
+    const active = this.active?.goal;
+    if (!active) return stored;
+    const rest = stored.filter((g) => g.id !== active.id);
+    return [structuredClone(active), ...rest];
+  }
+  /**
+   * Cancels a running goal and resolves once it has stopped. A goal left unfinished by an earlier
+   * process is marked cancelled; a finished goal is returned unchanged.
+   */
+  async cancel(id) {
+    if (this.active?.goal.id === id) {
+      this.active.controller.abort();
+      return structuredClone(await this.active.done);
     }
-  };
-}
-var PARSERS = {
-  claude: claudeParser,
-  codex: codexParser,
-  agy: agyParser
+    const goal = await this.options.store.load(id);
+    if (!goal) throw new GoalError("not_found", `unknown goal "${id}"`);
+    if (isTerminalGoal(goal)) return goal;
+    const stamp = this.now().toISOString();
+    goal.status = "cancelled";
+    goal.updatedAt = stamp;
+    goal.finishedAt = stamp;
+    delete goal.activeTaskId;
+    await this.options.store.save(goal);
+    return goal;
+  }
+  /** Resolves when the goal is finished (immediately for stored goals). */
+  async wait(id) {
+    if (this.active?.goal.id === id) return structuredClone(await this.active.done);
+    return this.options.store.load(id);
+  }
 };
-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}` : ""}`);
+var GOAL_ID = /^goal_[a-z0-9]{6,32}$/;
+var goalTaskSchema = z15.object({
+  id: z15.string().min(1),
+  title: z15.string(),
+  description: z15.string().optional(),
+  role: z15.string(),
+  kind: z15.enum(["code", "artifact"]),
+  status: taskStatusSchema,
+  dependsOn: z15.array(z15.string()),
+  acceptance: z15.array(z15.string()).optional(),
+  round: z15.number().int().min(1),
+  attempts: z15.number().int().min(0),
+  artifact: z15.string().optional(),
+  runnerTaskId: z15.string().optional(),
+  notes: z15.string().optional()
+});
+var goalSchema = z15.object({
+  id: z15.string().regex(GOAL_ID),
+  objective: z15.string().min(1),
+  status: z15.enum([
+    "planning",
+    "running",
+    "reviewing",
+    "planned",
+    "succeeded",
+    "failed",
+    "cancelled",
+    "budget_exhausted"
+  ]),
+  round: z15.number().int().min(0),
+  limits: z15.object({
+    maxRounds: z15.number().int().min(1),
+    maxTasks: z15.number().int().min(1),
+    maxTokens: z15.number().int().min(1),
+    tokensUsed: z15.number().int().min(0)
+  }),
+  roles: z15.array(
+    z15.object({ id: z15.string(), description: z15.string(), route: z15.string().optional() })
+  ),
+  tasks: z15.array(goalTaskSchema),
+  activeTaskId: z15.string().optional(),
+  summary: z15.string().optional(),
+  lastError: z15.string().optional(),
+  dryRun: z15.boolean().optional(),
+  createdAt: z15.string(),
+  updatedAt: z15.string(),
+  finishedAt: z15.string().optional()
+});
+function isGoalId(id) {
+  return GOAL_ID.test(id);
 }
-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;
+var GoalStore = class {
+  constructor(root) {
+    this.root = root;
+    this.dir = join7(projectPaths(root).dir, "goals");
+  }
+  root;
+  dir;
+  goalDir(id) {
+    if (!isGoalId(id)) throw new Error(`invalid goal id: ${id}`);
+    return join7(this.dir, id);
+  }
+  async save(goal) {
+    await atomicWriteFile(
+      join7(this.goalDir(goal.id), "goal.json"),
+      `${JSON.stringify(goal, null, 2)}
+`
+    );
+  }
+  /** The goal, or `undefined` when unknown. Throws when `goal.json` is corrupt. */
+  async load(id) {
+    if (!isGoalId(id)) return void 0;
+    const text = await readFileIfExists(join7(this.goalDir(id), "goal.json"));
+    if (text === void 0) return void 0;
+    return goalSchema.parse(JSON.parse(text));
+  }
+  /** Every readable goal, newest first. Corrupt entries are skipped. */
+  async list() {
+    let names;
     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;
+      names = await readdir3(this.dir);
+    } catch (err) {
+      if (isNodeError(err, "ENOENT")) return [];
+      throw err;
     }
-    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;
+    const goals = [];
+    for (const name of names.filter(isGoalId)) {
       try {
-        exit = await cli.exit;
+        const goal = await this.load(name);
+        if (goal) goals.push(goal);
       } 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 goals.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
   }
-  return {
-    async availability() {
-      return ORCHESTRATOR_AGENTS.map((agent) => ({ agent, available: isAvailable(agent) }));
-    },
-    run
+  /** Writes a task's markdown artifact and returns its repository-relative path (`/`-separated). */
+  async writeArtifact(goalId, taskId, markdown) {
+    const path11 = join7(this.goalDir(goalId), `${taskId}.md`);
+    await atomicWriteFile(path11, markdown.endsWith("\n") ? markdown : `${markdown}
+`);
+    return relative2(this.root, path11).split("\\").join("/");
+  }
+  async readArtifact(goalId, taskId) {
+    if (!isGoalId(goalId) || !/^[-a-zA-Z0-9_]{1,64}$/.test(taskId)) return void 0;
+    return readFileIfExists(join7(this.goalDir(goalId), `${taskId}.md`));
+  }
+};
+var PROJECT_CONTEXT_CHARS = 3e3;
+function createGoalService(engine, opts) {
+  const { brain } = opts;
+  const lock = opts.lock ?? new WorkspaceLock();
+  const store = new GoalStore(brain.root);
+  const codeRunner = new RunnerCodeTasks({
+    engine,
+    brain,
+    lock,
+    ...opts.budgetContext ? { contextExtras: opts.budgetContext } : {},
+    ...opts.executor ? { executor: opts.executor } : {}
+  });
+  const projectContext = async () => {
+    if (!await brain.isInitialised()) return "";
+    const [architecture, state] = await Promise.all([brain.readArchitecture(), brain.readState()]);
+    return [
+      `ARCHITECTURE.md:
+${truncateHead(architecture.trim(), PROJECT_CONTEXT_CHARS)}`,
+      `STATE.md:
+${truncateHead(state.trim(), PROJECT_CONTEXT_CHARS)}`
+    ].join("\n\n");
   };
-}
-function errText(err) {
-  return err instanceof Error ? err.message : String(err);
+  const orchestrator = new GoalOrchestrator({
+    router: engine.router,
+    store,
+    events: engine.events,
+    config: engine.config.goal,
+    codeRunner,
+    projectContext,
+    ...opts.budgetContext ? { budgetContext: opts.budgetContext } : {}
+  });
+  return new GoalService({ orchestrator, store, lock });
 }
 var AGENT_DESCRIPTIONS = {
   claude: "Claude Code (Anthropic): careful multi-file changes, refactors and reasoning about existing code.",
@@ -10330,15 +11137,15 @@ function buildTaskPrompt(input) {
   );
   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 dependencySchema = z16.union([z16.number(), z16.string()]);
+var plannedTaskSchema2 = z16.object({
+  title: z16.string().trim().min(1),
+  agent: z16.string().optional(),
+  prompt: z16.string().trim().min(1),
+  dependsOn: z16.array(dependencySchema).nullish()
 });
-var planReplySchema = z13.object({
-  tasks: z13.array(plannedTaskSchema2).min(1, "the plan has no tasks")
+var planReplySchema = z16.object({
+  tasks: z16.array(plannedTaskSchema2).min(1, "the plan has no tasks")
 });
 function dependencyIndex(value) {
   if (typeof value === "number") return Number.isInteger(value) ? value : void 0;
@@ -10351,8 +11158,8 @@ function clip2(text, max) {
 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}`;
+  const path11 = issue.path.length > 0 ? `${issue.path.join(".")}: ` : "";
+  return `${path11}${issue.message}`;
 }
 function findCycle(tasks) {
   const byId = new Map(tasks.map((t) => [t.id, t]));
@@ -10420,45 +11227,45 @@ function parsePlan(text, options) {
   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(),
+var agentSchema = z17.enum(ORCHESTRATOR_AGENTS);
+var taskSchema = z17.object({
+  id: z17.string().min(1),
+  title: z17.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()
+  prompt: z17.string(),
+  dependsOn: z17.array(z17.string()),
+  status: z17.enum(["pending", "running", "done", "failed", "conflict", "cancelled", "skipped"]),
+  branch: z17.string().optional(),
+  summary: z17.string().optional(),
+  changedFiles: z17.array(z17.string()).optional(),
+  error: z17.string().optional(),
+  startedAt: z17.string().optional(),
+  finishedAt: z17.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),
+var orchestratorRunSchema = z17.object({
+  id: z17.string().min(1),
+  objective: z17.string(),
+  status: z17.enum(["planning", "running", "done", "failed", "cancelled"]),
+  agents: z17.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()
+  baseBranch: z17.string().optional(),
+  baseCommit: z17.string().optional(),
+  integrationBranch: z17.string().optional(),
+  tasks: z17.array(taskSchema),
+  summary: z17.string().optional(),
+  error: z17.string().optional(),
+  appliedAt: z17.string().optional(),
+  createdAt: z17.string(),
+  updatedAt: z17.string()
 });
-var fileSchema2 = z14.object({
-  version: z14.literal(1),
-  runs: z14.array(z14.unknown())
+var fileSchema2 = z17.object({
+  version: z17.literal(1),
+  runs: z17.array(z17.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);
+  const hash = createHash4("sha256").update(key).digest("hex").slice(0, 16);
   return join8(home, "orchestrator", hash, "runs.json");
 }
 function newestFirst(runs) {
@@ -10478,7 +11285,7 @@ var OrchestratorStore = class {
   load() {
     let text;
     try {
-      text = readFileSync4(this.path, "utf8");
+      text = readFileSync5(this.path, "utf8");
     } catch {
       return [];
     }
@@ -10561,7 +11368,7 @@ var OrchestratorEngine = class {
   constructor(options) {
     this.options = options;
     this.now = options.now ?? (() => /* @__PURE__ */ new Date());
-    this.newId = options.newId ?? (() => randomBytes9(6).toString("hex"));
+    this.newId = options.newId ?? (() => randomBytes10(6).toString("hex"));
     this.store = new OrchestratorStore(options.home, options.projectDir);
     this.runs = this.store.load();
     this.recoverInterrupted();
@@ -10987,7 +11794,7 @@ function describeOutcome(task) {
 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"];
+var FALLBACK_IDENTITY2 = ["-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, "");
@@ -11007,27 +11814,27 @@ function errMessage(err) {
 }
 function realPath2(p) {
   try {
-    return realpathSync2.native(p);
+    return realpathSync3.native(p);
   } catch {
-    return path9.resolve(p);
+    return path10.resolve(p);
   }
 }
-function samePath(a, b) {
+function samePath2(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);
+  const rel = path10.relative(realPath2(parent), realPath2(child));
+  return rel === "" || !rel.startsWith("..") && !path10.isAbsolute(rel);
 }
 function createGitWorkspace(options) {
-  const projectDir = path9.resolve(options.projectDir);
-  const worktreesDir = path9.resolve(options.worktreesDir);
+  const projectDir = path10.resolve(options.projectDir);
+  const worktreesDir = path10.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 runDir = (runId) => path10.join(worktreesDir, assertId("run id", runId));
+  const integrationPath = (runId) => path10.join(runDir(runId), INTEGRATION_DIR);
   const integrationBranch = (runId) => `davecode/run-${assertId("run id", runId)}`;
   const taskBases = /* @__PURE__ */ new Map();
   let queue = Promise.resolve();
@@ -11045,7 +11852,7 @@ function createGitWorkspace(options) {
       hasIdentity = true;
       return [];
     } catch {
-      return FALLBACK_IDENTITY;
+      return FALLBACK_IDENTITY2;
     }
   }
   async function removeWorktree(target) {
@@ -11053,8 +11860,8 @@ function createGitWorkspace(options) {
       await repo.run(["worktree", "remove", "--force", target]);
     } catch {
     }
-    if (existsSync5(target)) {
-      rmSync5(target, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+    if (existsSync6(target)) {
+      rmSync6(target, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
     }
     try {
       await repo.run(["worktree", "prune"]);
@@ -11130,10 +11937,10 @@ function createGitWorkspace(options) {
           throw new GitError(`Invalid task id: ${JSON.stringify(taskId)}`, [], null, "");
         }
         const branch = `${integrationBranch(runId)}-${taskId}`;
-        const target = path9.join(runDir(runId), taskId);
+        const target = path10.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);
+        taskBases.set(path10.resolve(target), baseCommit);
         return { path: target, branch };
       });
     },
@@ -11153,7 +11960,7 @@ function createGitWorkspace(options) {
             message
           ]);
         }
-        const base = taskBases.get(path9.resolve(workspace.path));
+        const base = taskBases.get(path10.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"]));
@@ -11162,7 +11969,7 @@ function createGitWorkspace(options) {
     mergeIntoIntegration(runId, branch, message) {
       return serial(async () => {
         const target = integrationPath(runId);
-        if (!existsSync5(target)) {
+        if (!existsSync6(target)) {
           return { ok: false, reason: `The integration worktree for run ${runId} is missing` };
         }
         return merge(gitAt(target), branch, message, true);
@@ -11207,18 +12014,18 @@ function createGitWorkspace(options) {
           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));
+          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) && !samePath2(p, projectDir));
           for (const target of listed) {
             try {
               await repo.run(["worktree", "remove", "--force", target]);
             } catch {
             }
-            taskBases.delete(path9.resolve(target));
+            taskBases.delete(path10.resolve(target));
           }
         } catch {
         }
         try {
-          rmSync5(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+          rmSync6(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
         } catch {
         }
         try {
@@ -11412,6 +12219,27 @@ export {
   createAccountControl,
   BRAND_MARK_SVG,
   brandLogo,
+  CHANGES_LIMITS,
+  MAIN_WORKSPACE_ID,
+  WORKSPACE_ID_PATTERN,
+  PANE_BRANCH_PREFIX,
+  workspaceIdSchema,
+  createWorkspaceSchema,
+  suggestSchema,
+  shipSchema,
+  mergeSchema,
+  removeSchema,
+  ChangesError,
+  ORCHESTRATOR_AGENTS,
+  ORCHESTRATOR_LIMITS,
+  startRunSchema,
+  OrchestratorError,
+  createCliAgentRunner,
+  fallbackSuggestion,
+  parseAgentSuggestion,
+  paneWorktreesDir,
+  paneWorkspacePath,
+  createChangesService,
   DEFAULT_ROLES,
   resolveRoles,
   outboundAction,
@@ -11427,12 +12255,7 @@ export {
   isGoalId,
   GoalStore,
   createGoalService,
-  ORCHESTRATOR_AGENTS,
-  ORCHESTRATOR_LIMITS,
-  startRunSchema,
-  OrchestratorError,
-  createCliAgentRunner,
   createOrchestratorService,
   createGitWorkspace
 };
-//# sourceMappingURL=chunk-2XGDILCW.js.map
+//# sourceMappingURL=chunk-NBQIMB43.js.map