@dmrlzz/davecode 0.3.0 → 0.5.0

package/dist/{chunk-C7FDRA3U.js → chunk-HSBJDV3O.js}

@@ -86,6 +86,7 @@ import { existsSync, mkdirSync, statSync } from "fs";
 import path from "path";
 import path3 from "path";
 import path4 from "path";
+import path5 from "path";
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, rmSync, writeFileSync } from "fs";
 import { isAbsolute, join as join4, relative, resolve as resolve2 } from "path";
 import { mkdirSync as mkdirSync6 } from "fs";
@@ -103,17 +104,25 @@ import { mkdirSync as mkdirSync5 } from "fs";
 import { dirname as dirname5 } from "path";
 import BetterSqlite3 from "better-sqlite3";
 import { spawn as spawn3, spawnSync as spawnSync2 } from "child_process";
-import path5 from "path";
-import { mkdir as mkdir4, readdir as readdir2, readFile as readFile4, realpath, stat as stat3, writeFile as writeFile2 } from "fs/promises";
 import path6 from "path";
+import { mkdir as mkdir4, readdir as readdir2, readFile as readFile4, realpath, stat as stat3, writeFile as writeFile2 } from "fs/promises";
+import path7 from "path";
 import { z as z6 } from "zod";
 import { execFile } from "child_process";
 import { z as z7 } from "zod";
 import { basename as basename2, resolve as resolve4 } from "path";
+import { createHash as createHash2, randomBytes as randomBytes6 } from "crypto";
 import { z as z8 } from "zod";
-import { readdir as readdir3 } from "fs/promises";
-import { join as join6, relative as relative2 } from "path";
+import { randomBytes as randomBytes7 } from "crypto";
+import { createServer } from "http";
+import { createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2, randomBytes as randomBytes8 } from "crypto";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync3, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
+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";
 var credentials = z.object({ clientId: z.string().min(1), clientSecret: z.string().min(1) });
 var optionsSchema = z.object({
   origin: z.string().url().refine((value) => {
@@ -544,14 +553,14 @@ function projectPaths(root) {
 }
 var sleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
 var RETRYABLE_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]);
-async function atomicWriteFile(path7, content) {
-  await mkdir(dirname(path7), { recursive: true });
-  const tmp = `${path7}.${process.pid}.${randomBytes2(4).toString("hex")}.tmp`;
+async function atomicWriteFile(path8, content) {
+  await mkdir(dirname(path8), { recursive: true });
+  const tmp = `${path8}.${process.pid}.${randomBytes2(4).toString("hex")}.tmp`;
   try {
     await writeFile(tmp, content, "utf8");
     for (let attempt = 0; ; attempt++) {
       try {
-        await rename(tmp, path7);
+        await rename(tmp, path8);
         return;
       } catch (err) {
         const code = err.code;
@@ -564,9 +573,9 @@ async function atomicWriteFile(path7, content) {
     throw err;
   }
 }
-async function readFileIfExists(path7) {
+async function readFileIfExists(path8) {
   try {
-    return await readFile(path7, "utf8");
+    return await readFile(path8, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return void 0;
     throw err;
@@ -998,9 +1007,9 @@ var LockTimeoutError = class extends Error {
 };
 var TRANSIENT_OPEN_ERRORS = ["EPERM", "EACCES", "EBUSY"];
 var sleep2 = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
-async function readLockInfo(path7) {
+async function readLockInfo(path8) {
   try {
-    const parsed = JSON.parse(await readFile2(path7, "utf8"));
+    const parsed = JSON.parse(await readFile2(path8, "utf8"));
     if (typeof parsed === "object" && parsed !== null && typeof parsed.ts === "number" && typeof parsed.pid === "number") {
       return parsed;
     }
@@ -1008,11 +1017,11 @@ async function readLockInfo(path7) {
   }
   return void 0;
 }
-async function lockAge(path7) {
-  const info = await readLockInfo(path7);
+async function lockAge(path8) {
+  const info = await readLockInfo(path8);
   if (info) return Date.now() - info.ts;
   try {
-    return Date.now() - (await stat2(path7)).mtimeMs;
+    return Date.now() - (await stat2(path8)).mtimeMs;
   } catch {
     return void 0;
   }
@@ -1059,9 +1068,9 @@ async function withFileLock(lockPath, fn2, opts = {}) {
     }
   }
 }
-async function exists(path7) {
+async function exists(path8) {
   try {
-    await access(path7);
+    await access(path8);
     return true;
   } catch {
     return false;
@@ -1120,8 +1129,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(path7) {
-    super(`Missing project brain file: ${path7} (run ProjectBrain.init first)`);
+  constructor(path8) {
+    super(`Missing project brain file: ${path8} (run ProjectBrain.init first)`);
     this.name = "MissingBrainError";
   }
 };
@@ -1159,8 +1168,8 @@ var ProjectBrain = class _ProjectBrain {
       [brain.paths.architecture, architectureTemplate(name)],
       [brain.paths.taskGraph, serializeGraph(taskGraphTemplate())]
     ];
-    for (const [path7, content] of files) {
-      if (!await exists(path7)) await atomicWriteFile(path7, content);
+    for (const [path8, content] of files) {
+      if (!await exists(path8)) await atomicWriteFile(path8, content);
     }
     return brain;
   }
@@ -1272,10 +1281,10 @@ ${line}` : line);
     this.events?.emit({ type: "task.updated", task });
     return task;
   }
-  async readText(path7) {
-    const content = await readFileIfExists(path7);
+  async readText(path8) {
+    const content = await readFileIfExists(path8);
     if (content === void 0) {
-      throw new MissingBrainError(path7);
+      throw new MissingBrainError(path8);
     }
     return content;
   }
@@ -1288,6 +1297,7 @@ var providerKind = z3.enum([
   "claude-cli",
   "codex-cli",
   "gemini-cli",
+  "antigravity-cli",
   "gemini-web"
 ]);
 var routeTargetSchema = z3.object({
@@ -1473,23 +1483,23 @@ function deepMerge(base, override) {
   }
   return out;
 }
-function readLayer(path7) {
+function readLayer(path8) {
   let raw;
   try {
-    raw = readFileSync(path7, "utf8");
+    raw = readFileSync(path8, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return void 0;
-    throw new ConfigError(path7, `cannot read file: ${err.message}`, { cause: err });
+    throw new ConfigError(path8, `cannot read file: ${err.message}`, { cause: err });
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
-    throw new ConfigError(path7, `malformed JSON: ${err.message}`, { cause: err });
+    throw new ConfigError(path8, `malformed JSON: ${err.message}`, { cause: err });
   }
-  if (!isPlainObject(parsed)) throw new ConfigError(path7, "expected a JSON object");
+  if (!isPlainObject(parsed)) throw new ConfigError(path8, "expected a JSON object");
   const result = configSchema.safeParse(parsed);
-  if (!result.success) throw new ConfigError(path7, z4.prettifyError(result.error));
+  if (!result.success) throw new ConfigError(path8, z4.prettifyError(result.error));
   return parsed;
 }
 var TRUE_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
@@ -1561,19 +1571,19 @@ function loadConfig(options = {}) {
 }
 var isPlainObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 async function writeGlobalRouting(home, update, lock = {}) {
-  const path7 = globalPaths(home).config;
+  const path8 = globalPaths(home).config;
   return withFileLock(
-    `${path7}.lock`,
+    `${path8}.lock`,
     async () => {
       let current = {};
       try {
-        const parsed = JSON.parse(await readFile3(path7, "utf8"));
-        if (!isPlainObject2(parsed)) throw new ConfigError(path7, "expected a JSON object");
+        const parsed = JSON.parse(await readFile3(path8, "utf8"));
+        if (!isPlainObject2(parsed)) throw new ConfigError(path8, "expected a JSON object");
         current = parsed;
       } catch (err) {
         if (err instanceof ConfigError) throw err;
         if (!isNodeError(err, "ENOENT")) {
-          throw new ConfigError(path7, `cannot update this file: ${err.message}`, {
+          throw new ConfigError(path8, `cannot update this file: ${err.message}`, {
             cause: err
           });
         }
@@ -1588,11 +1598,11 @@ async function writeGlobalRouting(home, update, lock = {}) {
         }
       };
       const checked = configSchema.safeParse(next);
-      if (!checked.success) throw new ConfigError(path7, z5.prettifyError(checked.error));
-      await atomicWriteFile(path7, `${JSON.stringify(next, null, 2)}
+      if (!checked.success) throw new ConfigError(path8, z5.prettifyError(checked.error));
+      await atomicWriteFile(path8, `${JSON.stringify(next, null, 2)}
 `);
       return {
-        path: path7,
+        path: path8,
         routes: checked.data.routing.routes,
         defaultRoute: checked.data.routing.defaultRoute
       };
@@ -1680,8 +1690,8 @@ function makeUsage(prompt, completion) {
 function stripProviderPrefix(model, provider) {
   return model.startsWith(`${provider}/`) ? model.slice(provider.length + 1) : model;
 }
-function joinUrl(base, path7) {
-  return `${base.replace(/\/+$/, "")}/${path7.replace(/^\/+/, "")}`;
+function joinUrl(base, path8) {
+  return `${base.replace(/\/+$/, "")}/${path8.replace(/^\/+/, "")}`;
 }
 function configString(config, key) {
   const value = config[key];
@@ -2498,8 +2508,8 @@ var SHELL_SAFE = /^[\w.:=@+\-/\\[\]]+$/;
 function isShellSafeArg(arg) {
   return SHELL_SAFE.test(arg);
 }
-function quoteCommand(path7) {
-  return isShellSafeArg(path7) ? path7 : `"${path7}"`;
+function quoteCommand(path8) {
+  return isShellSafeArg(path8) ? path8 : `"${path8}"`;
 }
 function killTree(child) {
   if (child.pid === void 0 || child.exitCode !== null) return;
@@ -2709,8 +2719,121 @@ async function collectCompletion(chunks, model) {
     usage
   };
 }
-var DEFAULT_MODELS = ["default", "sonnet", "opus", "haiku"];
 var SAFE_MODEL = /^[\w.:[\]-]+$/;
+var AntigravityCliProvider = class {
+  kind = "antigravity-cli";
+  async listModels(ctx) {
+    const configured = configStringArray(ctx.account.config, "models");
+    return modelList(configured.length > 0 ? configured : ["default"], this.kind);
+  }
+  async complete(req, ctx) {
+    return collectCompletion(this.stream(req, ctx), stripProviderPrefix(req.model, this.kind));
+  }
+  async *stream(req, ctx) {
+    const model = stripProviderPrefix(req.model, this.kind);
+    if (model && !SAFE_MODEL.test(model)) {
+      throw new ProviderError("antigravity-cli: unsupported characters in model id", {
+        kind: "bad_request",
+        provider: this.kind,
+        accountId: ctx.account.id
+      });
+    }
+    const args = [
+      "--input-format",
+      "stream-json",
+      "--output-format",
+      "stream-json",
+      "--sandbox",
+      "--disable-slash-commands"
+    ];
+    if (model && model !== "default") args.push("--model", model);
+    args.push("--print=");
+    const run = runCli({
+      provider: this.kind,
+      accountId: ctx.account.id,
+      settings: cliSettings(ctx, "agy"),
+      args,
+      env: {},
+      cwd: configString(ctx.account.config, "cwd") ?? path2.resolve(ctx.sandboxDir),
+      stdin: `${JSON.stringify({
+        event: "user",
+        message: { content: renderTranscript(req.messages, true) }
+      })}
+`,
+      signal: ctx.signal
+    });
+    const id = newId();
+    const created = nowSeconds();
+    let started = false;
+    let streamed = false;
+    let completed = false;
+    let failure;
+    const fail = (message) => {
+      const { kind, retryAfterMs } = classifyCliText(message);
+      return new ProviderError(`antigravity-cli: ${redact(message, ctx.secret).slice(0, 500)}`, {
+        kind,
+        retryAfterMs,
+        provider: this.kind,
+        accountId: ctx.account.id
+      });
+    };
+    const start = function* () {
+      if (started) return;
+      started = true;
+      yield makeChunk(id, model, created, { role: "assistant", content: "" });
+    };
+    for await (const raw of run.events) {
+      if (!isRecord(raw)) continue;
+      const event = asString(raw.event);
+      if (event === "step_update" && isRecord(raw.step_update)) {
+        const step = raw.step_update;
+        const delta = asString(step.text_delta);
+        if (asString(step.step_type) === "agent_response" && delta) {
+          yield* start();
+          streamed = true;
+          yield makeChunk(id, model, created, { content: delta });
+        }
+        continue;
+      }
+      if (event === "result" && isRecord(raw.result)) {
+        const result = raw.result;
+        if (asString(result.status) !== "SUCCESS") {
+          failure = asString(result.error) ?? `Antigravity ended with ${result.status}`;
+          break;
+        }
+        completed = true;
+        yield* start();
+        const response = asString(result.response);
+        if (!streamed && response) yield makeChunk(id, model, created, { content: response });
+        const u = isRecord(result.usage) ? result.usage : {};
+        const output = (asNumber(u.output_tokens) ?? 0) + (asNumber(u.thinking_tokens) ?? 0);
+        yield makeChunk(
+          id,
+          model,
+          created,
+          {},
+          "stop",
+          makeUsage(asNumber(u.input_tokens) ?? 0, output)
+        );
+        break;
+      }
+    }
+    const exit = await run.exit;
+    if (exit.aborted || ctx.signal?.aborted) {
+      throw new ProviderError("antigravity-cli request aborted", {
+        kind: "timeout",
+        provider: this.kind,
+        accountId: ctx.account.id
+      });
+    }
+    if (failure) throw fail(failure);
+    if (!completed) {
+      throw fail(exit.stderr.trim() || `process exited with code ${exit.code ?? "unknown"}`);
+    }
+  }
+};
+var DEFAULT_MODELS = ["default", "sonnet", "opus", "haiku"];
+var SAFE_MODEL2 = /^[\w.:[\]-]+$/;
 var ClaudeCliProvider = class {
   kind = "claude-cli";
   async listModels(ctx) {
@@ -2734,7 +2857,7 @@ var ClaudeCliProvider = class {
     ];
     args.push("--no-session-persistence");
     if (model && model !== "default") {
-      if (!SAFE_MODEL.test(model)) {
+      if (!SAFE_MODEL2.test(model)) {
         throw new ProviderError("claude-cli: unsupported characters in model id", {
           kind: "bad_request",
           provider: this.kind,
@@ -2753,7 +2876,7 @@ var ClaudeCliProvider = class {
       settings,
       args,
       env: { CLAUDE_CONFIG_DIR: ctx.sandboxDir },
-      cwd: configString(ctx.account.config, "cwd") ?? path2.resolve(ctx.sandboxDir),
+      cwd: configString(ctx.account.config, "cwd") ?? path3.resolve(ctx.sandboxDir),
       stdin: renderTranscript(req.messages, shell),
       signal: ctx.signal
     });
@@ -2854,7 +2977,7 @@ var ClaudeCliProvider = class {
     }
   }
 };
-var SAFE_MODEL2 = /^[\w.:[\]-]+$/;
+var SAFE_MODEL3 = /^[\w.:[\]-]+$/;
 function agentText(item) {
   const type = asString(item.type);
   if (type && type !== "agent_message" && type !== "assistant_message") return void 0;
@@ -2882,7 +3005,7 @@ var CodexCliProvider = class {
   async *stream(req, ctx) {
     const model = stripProviderPrefix(req.model, this.kind);
     const sandbox = configString(ctx.account.config, "sandbox") ?? "read-only";
-    if (!SAFE_MODEL2.test(sandbox) || model && !SAFE_MODEL2.test(model)) {
+    if (!SAFE_MODEL3.test(sandbox) || model && !SAFE_MODEL3.test(model)) {
       throw new ProviderError("codex-cli: unsupported characters in model or sandbox setting", {
         kind: "bad_request",
         provider: this.kind,
@@ -2898,7 +3021,7 @@ var CodexCliProvider = class {
       settings: cliSettings(ctx, "codex"),
       args,
       env: { CODEX_HOME: ctx.sandboxDir },
-      cwd: configString(ctx.account.config, "cwd") ?? path3.resolve(ctx.sandboxDir),
+      cwd: configString(ctx.account.config, "cwd") ?? path4.resolve(ctx.sandboxDir),
       stdin: renderTranscript(req.messages, true),
       signal: ctx.signal
     });
@@ -3361,10 +3484,10 @@ var SandboxManager = class {
   }
 };
 var DEFAULT_MODELS2 = ["default", "gemini-2.5-pro", "gemini-2.5-flash"];
-var SAFE_MODEL3 = /^[\w.:[\]-]+$/;
+var SAFE_MODEL4 = /^[\w.:[\]-]+$/;
 function geminiCliEnv(sandboxDir) {
   return {
-    ...geminiHomeEnv(path4.resolve(sandboxDir)),
+    ...geminiHomeEnv(path5.resolve(sandboxDir)),
     GEMINI_API_KEY: "",
     GOOGLE_API_KEY: "",
     GOOGLE_GENAI_USE_VERTEXAI: ""
@@ -3386,7 +3509,7 @@ var GeminiCliProvider = class {
   }
   async *stream(req, ctx) {
     const model = stripProviderPrefix(req.model, this.kind);
-    if (model && !SAFE_MODEL3.test(model)) {
+    if (model && !SAFE_MODEL4.test(model)) {
       throw new ProviderError("gemini-cli: unsupported characters in model id", {
         kind: "bad_request",
         provider: this.kind,
@@ -3402,7 +3525,7 @@ var GeminiCliProvider = class {
       settings: cliSettings(ctx, "gemini"),
       args,
       env: geminiCliEnv(ctx.sandboxDir),
-      cwd: configString(ctx.account.config, "cwd") ?? path4.resolve(ctx.sandboxDir),
+      cwd: configString(ctx.account.config, "cwd") ?? path5.resolve(ctx.sandboxDir),
       stdin: renderTranscript(req.messages, true),
       signal: ctx.signal
     });
@@ -3747,6 +3870,7 @@ function createProviders(options = {}) {
     new ClaudeCliProvider(),
     new CodexCliProvider(),
     new GeminiCliProvider(),
+    new AntigravityCliProvider(),
     new GeminiWebProvider(options.geminiWebDriver)
   ];
   return new Map(providers.map((p) => [p.kind, p]));
@@ -3756,9 +3880,10 @@ var SUBSCRIPTION_PROVIDER_KINDS = [
   "claude-cli",
   "codex-cli",
   "gemini-cli",
+  "antigravity-cli",
   "gemini-web"
 ];
-var VERSION = "0.3.0";
+var VERSION = "0.5.0";
 var QUOTA_WINDOWS = ["1m", "5h", "24h"];
 var WINDOW_MS = {
   "1m": 6e4,
@@ -4152,6 +4277,13 @@ var CLI_LOGINS = {
     installHint: "Install Codex: npm install -g @openai/codex",
     instructions: "Codex opens the ChatGPT sign-in page and exits once you are logged in."
   },
+  "antigravity-cli": {
+    binary: "agy",
+    loginArgs: [],
+    statusArgs: ["models"],
+    installHint: "Install Antigravity: https://antigravity.google/docs/cli/install",
+    instructions: "Antigravity opens Google sign-in the first time it starts. Once its prompt appears, type /quit."
+  },
   "gemini-cli": {
     binary: "gemini",
     loginArgs: [],
@@ -4288,11 +4420,17 @@ var ConnectionChecker = class {
       if (!loggedIn)
         return result("not_connected", "Claude Code is not logged in for this account.");
       const isolated = this.platform === "darwin" || existsSync3(join5(dir, ".credentials.json"));
-      return result(
-        "connected",
-        isolated ? "Claude Code reports a login for this account." : "Claude Code reports a login, but none is stored in this account\u2019s sandbox: it is probably your global Claude Code login, so this account is not isolated."
+      return isolated ? result("connected", "Claude Code reports a login for this account.") : result(
+        "not_connected",
+        "Claude Code is signed in globally, but not for this account: sign in once for DaveCode."
       );
     }
+    if (account.provider === "antigravity-cli") {
+      return probed.code === 0 ? result(
+        "connected",
+        "Antigravity is signed in. Its login is shared by every Antigravity account on this machine."
+      ) : result("not_connected", "Antigravity is not signed in on this machine.");
+    }
     return probed.code === 0 ? result("connected", "Codex reports a login for this account.") : result("not_connected", "Codex is not logged in for this account.");
   }
 };
@@ -4499,6 +4637,7 @@ var PROVIDER_KINDS = [
   "claude-cli",
   "codex-cli",
   "gemini-cli",
+  "antigravity-cli",
   "gemini-web"
 ];
 var ROUTE_PREFIX = "davecode/";
@@ -4536,7 +4675,7 @@ function inferProviders(model) {
   const id = model.toLowerCase();
   if (id.startsWith("claude")) return ["anthropic", "claude-cli"];
   if (/^(gpt-|chatgpt|codex|o\d)/.test(id)) return ["openai", "codex-cli"];
-  if (id.startsWith("gemini")) return ["gemini", "gemini-cli", "gemini-web"];
+  if (id.startsWith("gemini")) return ["gemini", "gemini-cli", "antigravity-cli", "gemini-web"];
   return [];
 }
 function accountServes(account, model, provider) {
@@ -4675,8 +4814,23 @@ function messageText(message) {
   }
   return text;
 }
+function signInMessage(account) {
+  if (!CLI_LOGINS[account.provider]) return void 0;
+  return `${account.label} needs you to sign in again. Run: ${loginCommandFor(account.id)}`;
+}
+function withSignInHint(error, account) {
+  const message = error.kind === "auth" ? signInMessage(account) : void 0;
+  if (!message) return error;
+  return new ProviderError(message, {
+    kind: "auth",
+    provider: error.provider,
+    accountId: error.accountId,
+    ...error.status !== void 0 ? { status: error.status } : {},
+    cause: error
+  });
+}
 function toProviderError2(err, account) {
-  if (err instanceof ProviderError) return err;
+  if (err instanceof ProviderError) return withSignInHint(err, account);
   if (err instanceof KeyringError) {
     return new ProviderError(err.message, {
       kind: "auth",
@@ -4805,6 +4959,11 @@ var Router = class {
         { requestId }
       );
     }
+    if (reasons.size === 1 && reasons.has("error")) {
+      const failed = this.options.accounts.get(plan.skipped[0].accountId);
+      const message = failed && (signInMessage(failed) ?? failed.lastError);
+      if (message) return new RouterError("no_available_account", message, { requestId });
+    }
     return new RouterError(
       "no_available_account",
       `No available account for "${req.model}" (${[...reasons].join(", ")})`,
@@ -5372,9 +5531,9 @@ function migrate(db, migrations = MIGRATIONS) {
   }
   return version;
 }
-function openDatabase(path7, options = {}) {
-  if (path7 !== ":memory:") mkdirSync5(dirname5(path7), { recursive: true });
-  const db = new BetterSqlite3(path7);
+function openDatabase(path8, options = {}) {
+  if (path8 !== ":memory:") mkdirSync5(dirname5(path8), { recursive: true });
+  const db = new BetterSqlite3(path8);
   try {
     db.pragma("journal_mode = WAL");
     db.pragma("foreign_keys = ON");
@@ -5628,8 +5787,8 @@ function truncateHead(text, max) {
 function projectEnv(cwd, base = process.env) {
   const env = { ...base };
   const key = Object.keys(env).find((k) => k.toUpperCase() === "PATH") ?? "PATH";
-  const bin = path5.join(cwd, "node_modules", ".bin");
-  env[key] = env[key] ? `${bin}${path5.delimiter}${env[key]}` : bin;
+  const bin = path6.join(cwd, "node_modules", ".bin");
+  env[key] = env[key] ? `${bin}${path6.delimiter}${env[key]}` : bin;
   return env;
 }
 function killTree2(child) {
@@ -5795,8 +5954,8 @@ var MAX_FILE_BYTES = 1024 * 1024;
 var isWindows = process.platform === "win32";
 var same = (a, b) => isWindows ? a.toLowerCase() === b.toLowerCase() : a === b;
 function isInside(base, target) {
-  const rel = path6.relative(base, target);
-  return rel === "" || rel !== ".." && !rel.startsWith(`..${path6.sep}`) && !path6.isAbsolute(rel);
+  const rel = path7.relative(base, target);
+  return rel === "" || rel !== ".." && !rel.startsWith(`..${path7.sep}`) && !path7.isAbsolute(rel);
 }
 async function realpathLenient(target) {
   const missing = [];
@@ -5804,21 +5963,21 @@ async function realpathLenient(target) {
   for (; ; ) {
     try {
       const real = await realpath(current);
-      return missing.length > 0 ? path6.join(real, ...missing.reverse()) : real;
+      return missing.length > 0 ? path7.join(real, ...missing.reverse()) : real;
     } catch (err) {
       const code = err.code;
       if (code !== "ENOENT" && code !== "ENOTDIR") throw err;
-      const parent = path6.dirname(current);
+      const parent = path7.dirname(current);
       if (parent === current) return target;
-      missing.push(path6.basename(current));
+      missing.push(path7.basename(current));
       current = parent;
     }
   }
 }
 async function resolveRepoPath(root, input, mode = "read") {
   if (input.includes("\0")) throw new PathEscapeError("path contains a NUL byte");
-  const base = path6.resolve(root);
-  const abs = path6.resolve(base, input.trim() === "" ? "." : input);
+  const base = path7.resolve(root);
+  const abs = path7.resolve(base, input.trim() === "" ? "." : input);
   if (!isInside(base, abs)) {
     throw new PathEscapeError(`path "${input}" is outside the repository`);
   }
@@ -5827,7 +5986,7 @@ async function resolveRepoPath(root, input, mode = "read") {
   if (!isInside(realBase, real)) {
     throw new PathEscapeError(`path "${input}" resolves outside the repository (symlink)`);
   }
-  const rel = path6.relative(base, abs).split(path6.sep).join("/") || ".";
+  const rel = path7.relative(base, abs).split(path7.sep).join("/") || ".";
   const first = rel.split("/")[0] ?? "";
   if (same(first, ".git")) throw new PathEscapeError("the .git directory is off-limits");
   if (mode === "write" && same(first, ".davecode")) {
@@ -5983,7 +6142,7 @@ function countOccurrences(haystack, needle) {
   }
   return count;
 }
-var commandName = (command) => path6.basename(command).replace(/\.(exe|cmd|bat|com)$/i, "").toLowerCase();
+var commandName = (command) => path7.basename(command).replace(/\.(exe|cmd|bat|com)$/i, "").toLowerCase();
 var WorkspaceTools = class {
   root;
   readOnly;
@@ -5996,7 +6155,7 @@ var WorkspaceTools = class {
   maxOutput;
   env;
   constructor(opts) {
-    this.root = path6.resolve(opts.root);
+    this.root = path7.resolve(opts.root);
     this.readOnly = opts.readOnly ?? false;
     this.allowedCommands = (opts.allowedCommands ?? DEFAULT_ALLOWED_COMMANDS).map(
       (c) => c.toLowerCase()
@@ -6075,7 +6234,7 @@ var WorkspaceTools = class {
   }
   async writeFile(args) {
     const { abs, rel } = await resolveRepoPath(this.root, args.path, "write");
-    await mkdir4(path6.dirname(abs), { recursive: true });
+    await mkdir4(path7.dirname(abs), { recursive: true });
     const content = repairDoubleEscaped(args.content);
     await writeFile2(abs, content, "utf8");
     this.changedFiles.add(rel);
@@ -6131,8 +6290,8 @@ var WorkspaceTools = class {
     const ignored = await this.loadGitignoreMatcher();
     const results = [];
     const visitFile = async (file) => {
-      const rel = path6.relative(this.root, file).split(path6.sep).join("/");
-      if (ignored(rel, path6.basename(file), false)) return;
+      const rel = path7.relative(this.root, file).split(path7.sep).join("/");
+      if (ignored(rel, path7.basename(file), false)) return;
       const info2 = await stat3(file);
       if (info2.size > MAX_FILE_BYTES) return;
       const buffer = await readFile4(file);
@@ -6153,8 +6312,8 @@ var WorkspaceTools = class {
       entries.sort((a, b) => a.name.localeCompare(b.name));
       for (const entry of entries) {
         if (results.length >= args.max_results) return;
-        const full = path6.join(dir, entry.name);
-        const rel = path6.relative(this.root, full).split(path6.sep).join("/");
+        const full = path7.join(dir, entry.name);
+        const rel = path7.relative(this.root, full).split(path7.sep).join("/");
         if (entry.isDirectory()) {
           if (!SKIP_DIRS.has(entry.name) && !ignored(rel, entry.name, true)) await walk(full);
         } else if (entry.isFile()) {
@@ -6173,7 +6332,7 @@ var WorkspaceTools = class {
   async loadGitignoreMatcher() {
     let raw = "";
     try {
-      raw = await readFile4(path6.join(this.root, ".gitignore"), "utf8");
+      raw = await readFile4(path7.join(this.root, ".gitignore"), "utf8");
     } catch {
       return () => false;
     }
@@ -6467,7 +6626,7 @@ Rules:
 - Do not edit anything under .davecode/ (the runner maintains it) and do not commit, merge, push or switch branches: the runner owns git.
 - You may run the project's checks before finishing.
 - When the task is complete, reply with a concise summary of the change (it becomes the commit message body).`;
-var SAFE_MODEL4 = /^[\w.:[\]-]+$/;
+var SAFE_MODEL5 = /^[\w.:[\]-]+$/;
 var SAFE_SESSION = /^[A-Za-z0-9-]{8,128}$/;
 function selectClaudeAccount(accounts, accountId) {
   if (accountId) {
@@ -6518,7 +6677,7 @@ var ClaudeCliExecutor = class {
       const args = ["-p", "--output-format", "stream-json", "--verbose"];
       args.push("--permission-mode", "acceptEdits");
       if (opts.model) {
-        if (!SAFE_MODEL4.test(opts.model)) {
+        if (!SAFE_MODEL5.test(opts.model)) {
           throw new ExecutorError("runner.claudeCli.model contains unsupported characters");
         }
         args.push("--model", opts.model);
@@ -7900,6 +8059,357 @@ var ProjectBrainSource = class {
     return await readFileIfExists(this.brain.paths.architecture) ?? "";
   }
 };
+var ACCOUNT_SERVICE = {
+  url: "https://auth.davecode.app",
+  publishableKey: "davecode-cli"
+};
+function accountService(env = process.env) {
+  const url = env.DAVECODE_ACCOUNT_URL ?? ACCOUNT_SERVICE.url;
+  const publishableKey = env.DAVECODE_ACCOUNT_KEY ?? ACCOUNT_SERVICE.publishableKey;
+  return url && publishableKey ? { url: url.replace(/\/+$/, ""), publishableKey } : void 0;
+}
+var OAUTH_PROVIDERS = ["google", "github"];
+var AccountError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "AccountError";
+  }
+  status;
+};
+var userSchema = z8.object({
+  id: z8.string().min(1),
+  email: z8.string().optional().nullable(),
+  app_metadata: z8.object({ provider: z8.string().optional() }).passthrough().optional(),
+  user_metadata: z8.object({ full_name: z8.string().optional(), name: z8.string().optional() }).passthrough().optional()
+});
+var sessionSchema = z8.object({
+  access_token: z8.string().min(1),
+  refresh_token: z8.string().min(1),
+  expires_in: z8.number().positive(),
+  user: userSchema
+});
+var settingsSchema = z8.object({ external: z8.record(z8.string(), z8.boolean()) });
+var errorSchema = z8.object({
+  error_description: z8.string().optional(),
+  msg: z8.string().optional(),
+  message: z8.string().optional(),
+  error: z8.string().optional()
+}).passthrough();
+function pkcePair() {
+  const verifier = randomBytes6(48).toString("base64url");
+  return { verifier, challenge: createHash2("sha256").update(verifier).digest("base64url") };
+}
+function toSession(raw, now) {
+  const parsed = sessionSchema.safeParse(raw);
+  if (!parsed.success) throw new AccountError("The account service sent an unexpected reply.");
+  const { user } = parsed.data;
+  return {
+    accessToken: parsed.data.access_token,
+    refreshToken: parsed.data.refresh_token,
+    expiresAt: now + parsed.data.expires_in * 1e3,
+    user: {
+      id: user.id,
+      ...user.email ? { email: user.email } : {},
+      ...user.user_metadata?.full_name ?? user.user_metadata?.name ? { name: user.user_metadata?.full_name ?? user.user_metadata?.name } : {},
+      ...user.app_metadata?.provider ? { provider: user.app_metadata.provider } : {}
+    }
+  };
+}
+var AccountClient = class {
+  constructor(service, options = {}) {
+    this.service = service;
+    this.fetch = options.fetch ?? globalThis.fetch;
+    this.now = options.now ?? Date.now;
+  }
+  service;
+  fetch;
+  now;
+  /**
+   * The hosted sign-in page (Google, GitHub or email). Every method ends by sending the browser
+   * to `redirectTo` with `?code=` bound to `challenge`.
+   */
+  loginUrl(redirectTo, challenge) {
+    const url = new URL(`${this.service.url}/login`);
+    url.searchParams.set("redirect_to", redirectTo);
+    url.searchParams.set("code_challenge", challenge);
+    return url.toString();
+  }
+  /** A page of the hosted service, such as `/login/done`. */
+  pageUrl(path8) {
+    return `${this.service.url}${path8}`;
+  }
+  /** Browser URL that starts Google or GitHub sign-in and returns to `redirectTo` with `?code=`. */
+  authorizeUrl(provider, redirectTo, challenge) {
+    const url = new URL(`${this.service.url}/auth/v1/authorize`);
+    url.searchParams.set("provider", provider);
+    url.searchParams.set("redirect_to", redirectTo);
+    url.searchParams.set("code_challenge", challenge);
+    url.searchParams.set("code_challenge_method", "s256");
+    return url.toString();
+  }
+  exchangeCode(code, verifier) {
+    return this.session("token?grant_type=pkce", { auth_code: code, code_verifier: verifier });
+  }
+  signInWithPassword(email, password) {
+    return this.session("token?grant_type=password", { email, password });
+  }
+  /** Create an e-mail account. With confirmation on, the link returns to `redirectTo`. */
+  async signUp(email, password, redirectTo, challenge) {
+    const raw = await this.post(`signup?redirect_to=${encodeURIComponent(redirectTo)}`, {
+      email,
+      password,
+      code_challenge: challenge,
+      code_challenge_method: "s256"
+    });
+    if (sessionSchema.safeParse(raw).success) return { session: toSession(raw, this.now()) };
+    return { confirmEmail: true };
+  }
+  /** Sign-in methods the service has enabled; on any failure, assume all of them. */
+  async providers() {
+    try {
+      const response = await this.fetch(`${this.service.url}/auth/v1/settings`, {
+        headers: { apikey: this.service.publishableKey },
+        signal: AbortSignal.timeout(1e4)
+      });
+      const parsed = settingsSchema.safeParse(await response.json());
+      if (!response.ok || !parsed.success) return [...OAUTH_PROVIDERS];
+      return OAUTH_PROVIDERS.filter((p) => parsed.data.external[p] !== false);
+    } catch {
+      return [...OAUTH_PROVIDERS];
+    }
+  }
+  refresh(refreshToken) {
+    return this.session("token?grant_type=refresh_token", { refresh_token: refreshToken });
+  }
+  /** Revoke the session on the server. Best effort: the local copy is removed regardless. */
+  async signOut(accessToken) {
+    await this.fetch(`${this.service.url}/auth/v1/logout?scope=local`, {
+      method: "POST",
+      headers: { apikey: this.service.publishableKey, Authorization: `Bearer ${accessToken}` },
+      signal: AbortSignal.timeout(1e4)
+    }).catch(() => void 0);
+  }
+  async session(path8, body) {
+    return toSession(await this.post(path8, body), this.now());
+  }
+  async post(path8, body) {
+    let response;
+    try {
+      response = await this.fetch(`${this.service.url}/auth/v1/${path8}`, {
+        method: "POST",
+        headers: { apikey: this.service.publishableKey, "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(2e4)
+      });
+    } catch {
+      throw new AccountError("Cannot reach the DaveCode account service. Check your connection.");
+    }
+    const raw = await response.json().catch(() => void 0);
+    if (!response.ok) {
+      const error = errorSchema.safeParse(raw);
+      const detail = error.success ? error.data.error_description ?? error.data.msg ?? error.data.message : void 0;
+      throw new AccountError(
+        detail ?? `Sign-in failed (HTTP ${response.status}).`,
+        response.status
+      );
+    }
+    return raw;
+  }
+};
+function redirect(res, location) {
+  res.writeHead(302, { Location: location, "Cache-Control": "no-store" });
+  res.end();
+}
+async function startAccountLogin(options) {
+  const { client } = options;
+  const callbackPath = `/s/${randomBytes7(18).toString("base64url")}/callback`;
+  const pkce = pkcePair();
+  let finish = () => {
+  };
+  let fail = () => {
+  };
+  let settled = false;
+  const session = new Promise((resolve5, reject) => {
+    finish = resolve5;
+    fail = reject;
+  });
+  session.catch(() => {
+  });
+  const server = createServer((req, res) => {
+    void (async () => {
+      const url = new URL(req.url ?? "/", "http://127.0.0.1");
+      if (req.method !== "GET" || url.pathname !== callbackPath || settled) {
+        res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+        res.end("Not found");
+        return;
+      }
+      const code = url.searchParams.get("code");
+      if (!code) {
+        settled = true;
+        fail(
+          new AccountError(
+            url.searchParams.get("error_description") ?? "The sign-in was not completed."
+          )
+        );
+        redirect(res, client.pageUrl("/login/failed"));
+        return;
+      }
+      settled = true;
+      try {
+        finish(await client.exchangeCode(code, pkce.verifier));
+        redirect(res, client.pageUrl("/login/done"));
+      } catch (err) {
+        fail(err instanceof AccountError ? err : new AccountError("Sign-in failed."));
+        redirect(res, client.pageUrl("/login/failed"));
+      }
+    })().catch(() => {
+      if (!res.headersSent) res.writeHead(500).end();
+    });
+  });
+  await new Promise((resolve5, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => resolve5());
+  });
+  const port = server.address().port;
+  const close = () => new Promise((resolve5) => {
+    server.closeAllConnections();
+    server.close(() => resolve5());
+  });
+  const timeout = setTimeout(
+    () => {
+      fail(new AccountError("Sign-in timed out. Run davecode login to try again."));
+    },
+    options.timeoutMs ?? 10 * 6e4
+  );
+  timeout.unref();
+  void session.then(
+    () => setTimeout(() => void close(), 1e3).unref(),
+    () => setTimeout(() => void close(), 1e3).unref()
+  );
+  return {
+    url: client.loginUrl(`http://127.0.0.1:${port}${callbackPath}`, pkce.challenge),
+    session,
+    close: async () => {
+      clearTimeout(timeout);
+      fail(new AccountError("Sign-in cancelled."));
+      await close();
+    }
+  };
+}
+var AAD = Buffer.from("davecode-account", "utf8");
+var REFRESH_MARGIN_MS = 6e4;
+var fileSchema = z9.object({
+  v: z9.literal(1),
+  iv: z9.string(),
+  tag: z9.string(),
+  data: z9.string()
+});
+var sessionSchema2 = z9.object({
+  accessToken: z9.string().min(1),
+  refreshToken: z9.string().min(1),
+  expiresAt: z9.number(),
+  user: z9.object({
+    id: z9.string().min(1),
+    email: z9.string().optional(),
+    name: z9.string().optional(),
+    provider: z9.string().optional()
+  })
+});
+function accountFile(home) {
+  return join6(home, "account.json");
+}
+var AccountStore = class {
+  constructor(home, env = process.env) {
+    this.home = home;
+    this.path = accountFile(home);
+    this.key = loadMasterKey(globalPaths(home).masterKey, env);
+  }
+  home;
+  path;
+  key;
+  load() {
+    let raw;
+    try {
+      raw = readFileSync3(this.path, "utf8");
+    } catch {
+      return void 0;
+    }
+    try {
+      const file = fileSchema.parse(JSON.parse(raw));
+      const decipher = createDecipheriv2("aes-256-gcm", this.key, Buffer.from(file.iv, "base64"));
+      decipher.setAAD(AAD);
+      decipher.setAuthTag(Buffer.from(file.tag, "base64"));
+      const plain = Buffer.concat([
+        decipher.update(Buffer.from(file.data, "base64")),
+        decipher.final()
+      ]).toString("utf8");
+      return sessionSchema2.parse(JSON.parse(plain));
+    } catch {
+      return void 0;
+    }
+  }
+  save(session) {
+    const iv = randomBytes8(12);
+    const cipher = createCipheriv2("aes-256-gcm", this.key, iv);
+    cipher.setAAD(AAD);
+    const data = Buffer.concat([cipher.update(JSON.stringify(session), "utf8"), cipher.final()]);
+    mkdirSync7(dirname6(this.path), { recursive: true });
+    writeFileSync3(
+      this.path,
+      `${JSON.stringify({
+        v: 1,
+        iv: iv.toString("base64"),
+        tag: cipher.getAuthTag().toString("base64"),
+        data: data.toString("base64")
+      })}
+`,
+      { mode: 384 }
+    );
+  }
+  clear() {
+    rmSync3(this.path, { force: true });
+  }
+  /**
+   * The current session, refreshed when it is about to expire. Returns undefined when signed out
+   * or when the service revoked the session; offline, an unexpired session is still returned.
+   */
+  async current(client, now = Date.now()) {
+    const session = this.load();
+    if (!session) return void 0;
+    if (session.expiresAt - REFRESH_MARGIN_MS > now) return session;
+    try {
+      const fresh = await client.refresh(session.refreshToken);
+      this.save(fresh);
+      return fresh;
+    } catch (err) {
+      if (err instanceof AccountError && err.status !== void 0 && err.status < 500) {
+        this.clear();
+        return void 0;
+      }
+      return session;
+    }
+  }
+};
+var BRAND_MARK_SVG = '<svg viewBox="0 0 1214 1214" xmlns="http://www.w3.org/2000/svg" aria-hidden="true"><path fill="currentColor" fill-rule="evenodd" d="M324.3 1096.5C324.6 1095.4 326.5 1088.3 328.5 1080.8C341.4 1031.3 375.8 953.4 419.7 874.0C445.8 826.9 448.4 822.4 471.8 783.0C501.5 733.1 530.1 687.6 556.4 648.5C563.7 637.5 569.7 628.4 569.5 628.2C569.4 628.1 563.1 631.7 555.4 636.3C513.8 661.4 468.0 683.9 411.0 707.5C337.2 737.9 321.7 744.7 296.0 757.2C241.9 783.5 199.1 809.4 152.0 844.3C119.5 868.4 98.8 885.9 71.3 912.4C64.0 919.5 58.0 925.0 58.0 924.7C58.0 923.1 64.7 902.4 68.8 891.0C116.1 762.1 215.0 644.2 351.0 554.8C385.2 532.3 411.6 516.9 445.5 499.4C521.4 460.4 589.4 435.7 636.0 430.0C676.8 425.1 715.1 437.0 743.9 463.6C763.4 481.6 779.0 509.9 785.2 538.5C787.7 550.1 788.7 579.7 787.1 592.5C782.6 626.4 769.7 661.5 746.5 702.0C717.7 752.5 675.6 806.9 627.0 856.4C599.5 884.4 575.9 905.4 542.5 931.6C510.0 957.1 500.7 964.2 432.5 1015.0C409.4 1032.3 382.6 1052.5 373.0 1060.0C354.5 1074.4 327.4 1095.5 325.1 1097.4C324.0 1098.3 323.8 1098.1 324.3 1096.5ZM783.2 1017.8C797.1 999.5 820.2 966.0 831.7 947.5C868.5 888.3 888.8 840.5 903.4 778.5C917.9 716.9 921.2 643.7 912.0 591.0C904.6 549.3 889.7 511.9 866.7 477.5C856.6 462.3 853.1 457.8 837.4 439.6C817.4 416.6 806.6 402.0 800.5 389.5C793.6 375.5 791.7 368.1 791.7 356.0C791.7 335.3 799.3 319.6 819.0 299.9C849.7 269.2 900.2 247.9 956.8 241.9C963.0 241.2 967.7 240.3 967.3 239.9C966.1 238.8 948.5 236.3 933.0 234.9C913.6 233.2 875.2 234.3 859.0 237.0C839.7 240.2 827.8 242.9 813.0 247.5C753.9 265.9 700.6 300.9 659.2 348.5C648.9 360.4 636.6 376.5 632.4 383.5C630.3 387.1 629.0 388.2 624.7 389.6C603.8 396.4 554.6 417.6 513.5 437.5C447.6 469.4 395.4 496.8 341.5 528.1L337.5 530.4L339.5 527.9C340.6 526.6 346.2 520.3 352.0 514.0C374.4 489.6 390.2 470.8 411.2 443.5C429.3 419.9 444.6 398.2 488.5 333.5C510.5 301.0 529.1 278.0 550.9 256.3C593.0 214.1 640.3 183.6 691.5 165.5C727.7 152.8 756.5 147.7 792.5 147.7C854.3 147.8 906.4 164.9 954.1 200.6C967.5 210.8 974.1 214.6 981.5 217.0C991.4 220.1 1022.1 231.9 1038.5 238.8C1061.9 248.7 1099.0 267.4 1097.7 268.7C1097.4 268.9 1089.3 268.5 1079.7 267.9C1033.7 264.7 984.5 274.1 946.2 293.4C932.3 300.4 915.0 313.0 903.4 324.5C881.0 346.6 870.0 369.6 870.0 394.4C870.0 413.7 876.8 433.1 894.7 465.2C908.8 490.3 914.6 501.1 922.8 517.5C961.3 594.3 980.0 662.5 980.0 725.4C980.0 770.9 967.3 818.9 944.4 860.4C927.6 890.8 912.0 911.0 882.5 940.6C856.5 966.7 828.5 989.7 797.0 1010.7C779.6 1022.2 780.0 1022.0 783.2 1017.8Z"/></svg>';
+var LOGO_ART = [
+  "           \u2584\u2584\u2584\u2588\u2584\u2584\u2584",
+  "         \u2584\u2588\u2588\u2588\u2580\u2580\u2588\u2588\u2588\u2580\u2580",
+  "        \u2588\u2588\u2588\u2580   \u2588\u2580",
+  "       \u2588\u2588\u2584\u2584\u2588\u2588\u2584 \u2580\u2588",
+  "     \u2584\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588  \u2588",
+  "   \u2584\u2588\u2588\u2588\u2588\u2580\u2588\u2588\u2588\u2588\u2588   \u2588",
+  " \u2584\u2588\u2588\u2580\u2580  \u2584\u2588\u2588\u2588\u2588\u2580   \u2588\u2580",
+  "\u2584\u2580\u2580    \u2584\u2588\u2588\u2588\u2580    \u2584\u2588",
+  "      \u2584\u2588\u2588\u2580     \u2584\u2580",
+  "      \u2580"
+];
+function brandLogo(unicode = true) {
+  if (unicode) return [...LOGO_ART];
+  return LOGO_ART.map(
+    (line) => line.replaceAll("\u2588", "#").replaceAll("\u2580", '"').replaceAll("\u2584", ".")
+  );
+}
 var DEFAULT_ROLES = [
   {
     id: "planner",
@@ -7982,27 +8492,27 @@ ${task.description ?? ""}`;
   const description = [task.description?.trim(), DRAFT_NOTICE].filter(Boolean).join("\n\n");
   return { ...task, kind: "artifact", title: title.slice(0, 300), description };
 }
-var plannedTaskSchema = z8.object({
-  id: z8.string().min(1).max(80),
-  title: z8.string().trim().min(1).max(300),
-  description: z8.string().max(8e3).optional(),
-  role: z8.string().min(1).max(40),
-  kind: z8.enum(["code", "artifact"]).optional(),
-  dependsOn: z8.array(z8.string().min(1)).max(50).default([]),
-  acceptance: z8.array(z8.string().min(1).max(1e3)).max(20).optional()
+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 = z8.object({
-  summary: z8.string().max(4e3).optional(),
-  tasks: z8.array(plannedTaskSchema).min(1).max(100)
+var planSchema = z10.object({
+  summary: z10.string().max(4e3).optional(),
+  tasks: z10.array(plannedTaskSchema).min(1).max(100)
 });
-var reviewSchema = z8.object({
+var reviewSchema = z10.object({
   /** The objective is achieved as far as DaveCode can take it. */
-  done: z8.boolean(),
-  summary: z8.string().max(8e3),
+  done: z10.boolean(),
+  summary: z10.string().max(8e3),
   /** Ids of FAILED tasks worth another attempt. */
-  retry: z8.array(z8.string()).max(50).default([]),
+  retry: z10.array(z10.string()).max(50).default([]),
   /** New tasks for the next round. */
-  tasks: z8.array(plannedTaskSchema).max(50).default([])
+  tasks: z10.array(plannedTaskSchema).max(50).default([])
 });
 var TASK_ID = /^[a-z0-9]+(?:[-_.][a-z0-9]+)*$/;
 function sanitizeTaskId(raw) {
@@ -8766,25 +9276,25 @@ var GoalService = class {
   }
 };
 var GOAL_ID = /^goal_[a-z0-9]{6,32}$/;
-var goalTaskSchema = z9.object({
-  id: z9.string().min(1),
-  title: z9.string(),
-  description: z9.string().optional(),
-  role: z9.string(),
-  kind: z9.enum(["code", "artifact"]),
+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: z9.array(z9.string()),
-  acceptance: z9.array(z9.string()).optional(),
-  round: z9.number().int().min(1),
-  attempts: z9.number().int().min(0),
-  artifact: z9.string().optional(),
-  runnerTaskId: z9.string().optional(),
-  notes: z9.string().optional()
+  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 = z9.object({
-  id: z9.string().regex(GOAL_ID),
-  objective: z9.string().min(1),
-  status: z9.enum([
+var goalSchema = z11.object({
+  id: z11.string().regex(GOAL_ID),
+  objective: z11.string().min(1),
+  status: z11.enum([
     "planning",
     "running",
     "reviewing",
@@ -8794,24 +9304,24 @@ var goalSchema = z9.object({
     "cancelled",
     "budget_exhausted"
   ]),
-  round: z9.number().int().min(0),
-  limits: z9.object({
-    maxRounds: z9.number().int().min(1),
-    maxTasks: z9.number().int().min(1),
-    maxTokens: z9.number().int().min(1),
-    tokensUsed: z9.number().int().min(0)
+  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: z9.array(
-    z9.object({ id: z9.string(), description: z9.string(), route: z9.string().optional() })
+  roles: z11.array(
+    z11.object({ id: z11.string(), description: z11.string(), route: z11.string().optional() })
   ),
-  tasks: z9.array(goalTaskSchema),
-  activeTaskId: z9.string().optional(),
-  summary: z9.string().optional(),
-  lastError: z9.string().optional(),
-  dryRun: z9.boolean().optional(),
-  createdAt: z9.string(),
-  updatedAt: z9.string(),
-  finishedAt: z9.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);
@@ -8819,17 +9329,17 @@ function isGoalId(id) {
 var GoalStore = class {
   constructor(root) {
     this.root = root;
-    this.dir = join6(projectPaths(root).dir, "goals");
+    this.dir = join7(projectPaths(root).dir, "goals");
   }
   root;
   dir;
   goalDir(id) {
     if (!isGoalId(id)) throw new Error(`invalid goal id: ${id}`);
-    return join6(this.dir, id);
+    return join7(this.dir, id);
   }
   async save(goal) {
     await atomicWriteFile(
-      join6(this.goalDir(goal.id), "goal.json"),
+      join7(this.goalDir(goal.id), "goal.json"),
       `${JSON.stringify(goal, null, 2)}
 `
     );
@@ -8837,7 +9347,7 @@ var GoalStore = class {
   /** 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(join6(this.goalDir(id), "goal.json"));
+    const text = await readFileIfExists(join7(this.goalDir(id), "goal.json"));
     if (text === void 0) return void 0;
     return goalSchema.parse(JSON.parse(text));
   }
@@ -8862,14 +9372,14 @@ var GoalStore = class {
   }
   /** Writes a task's markdown artifact and returns its repository-relative path (`/`-separated). */
   async writeArtifact(goalId, taskId, markdown) {
-    const path7 = join6(this.goalDir(goalId), `${taskId}.md`);
-    await atomicWriteFile(path7, markdown.endsWith("\n") ? markdown : `${markdown}
+    const path8 = join7(this.goalDir(goalId), `${taskId}.md`);
+    await atomicWriteFile(path8, markdown.endsWith("\n") ? markdown : `${markdown}
 `);
-    return relative2(this.root, path7).split("\\").join("/");
+    return relative2(this.root, path8).split("\\").join("/");
   }
   async readArtifact(goalId, taskId) {
     if (!isGoalId(goalId) || !/^[-a-zA-Z0-9_]{1,64}$/.test(taskId)) return void 0;
-    return readFileIfExists(join6(this.goalDir(goalId), `${taskId}.md`));
+    return readFileIfExists(join7(this.goalDir(goalId), `${taskId}.md`));
   }
 };
 var PROJECT_CONTEXT_CHARS = 3e3;
@@ -9068,6 +9578,17 @@ export {
   createRunner,
   WorkspaceLock,
   ProjectBrainSource,
+  ACCOUNT_SERVICE,
+  accountService,
+  OAUTH_PROVIDERS,
+  AccountError,
+  pkcePair,
+  AccountClient,
+  startAccountLogin,
+  accountFile,
+  AccountStore,
+  BRAND_MARK_SVG,
+  brandLogo,
   DEFAULT_ROLES,
   resolveRoles,
   outboundAction,
@@ -9084,4 +9605,4 @@ export {
   GoalStore,
   createGoalService
 };
-//# sourceMappingURL=chunk-C7FDRA3U.js.map
+//# sourceMappingURL=chunk-HSBJDV3O.js.map