@botconnector/bccli 0.4.0-beta.38 → 0.4.0-beta.39

package/dist/cli.js

@@ -1,2107 +1,46 @@
 #!/usr/bin/env node
 import {
-  BUILTIN_AGENTS,
-  appendMemory,
-  bashTool,
-  buildSystemPrompt,
-  createBashTool,
-  defineTool,
-  ignorePatterns,
-  loadAgentDefs,
-  loadCommands,
-  loadSkills,
-  normalizeGlobPath,
-  parseFrontmatter,
+  VERSION
+} from "./chunk-PDZPPSLU.js";
+import {
   resolveWorktree,
-  runHooks,
-  runPrint,
-  validateGlobPattern
-} from "./chunk-HXSREA7S.js";
+  runPrint
+} from "./chunk-RV74TCEP.js";
 import {
   helpText,
   parseCliArgs
-} from "./chunk-ASTNW3X2.js";
+} from "./chunk-ZG7HCXYA.js";
 import {
-  Permissions
-} from "./chunk-R3ND76LW.js";
+  runLogin
+} from "./chunk-EONFDWBE.js";
 import {
-  addProviderKey,
-  listAllModels
-} from "./chunk-C6PKRYUX.js";
+  createRuntime
+} from "./chunk-QETGQXPL.js";
+import "./chunk-3HCOAJEQ.js";
+import "./chunk-ZMU7MXCH.js";
+import "./chunk-R3ND76LW.js";
+import "./chunk-JROUQ5YS.js";
+import "./chunk-LN32JIZR.js";
 import {
-  providerName,
   readGlobalConfigFile
-} from "./chunk-U66JJ6RN.js";
-import {
-  runLogin
-} from "./chunk-OB7FN66F.js";
+} from "./chunk-SESBH44L.js";
 import {
-  Session,
   pruneSessions
-} from "./chunk-XFTBML3H.js";
-import {
-  completionAssistantMessage,
-  createProvider,
-  hasPendingProgrammaticReplay,
-  imageUserMessage
-} from "./chunk-H66PC2EB.js";
-import "./chunk-YURAIW7A.js";
-import {
-  FileOAuthProvider,
-  hasStoredTokens
-} from "./chunk-3HCOAJEQ.js";
-import {
-  expandEnvVars
-} from "./chunk-TASYQW7B.js";
+} from "./chunk-VM7HYAJS.js";
+import "./chunk-GGNXHJL6.js";
+import "./chunk-NI5JZUZ3.js";
+import "./chunk-AVB6M4JE.js";
+import "./chunk-HE33XAPZ.js";
+import "./chunk-PSO7R5AD.js";
 import {
   ConfigError,
-  bccliHome,
-  loadConfig,
-  resolveModel
-} from "./chunk-H5N4ST6B.js";
+  setTheme
+} from "./chunk-M7LLJQ7M.js";
 import {
   resolveLanguage,
   setLanguage,
   t
-} from "./chunk-4RMP4CNT.js";
-
-// src/textToolCalls.ts
-var PAIR = /(?:<arg_key>\s*|`)?([A-Za-z_]\w*)(?:\s*<\/arg_key>)?`?\s*(?:=\s*`|<arg_value>)([\s\S]*?)<\/arg_value>/g;
-var CALL_START = /<tool_call>|\n?[^\n]*\bTool call list\b[^\n]*|\n\s*\d+\.\s*Tool:/g;
-function coerce(value, type) {
-  const types = Array.isArray(type) ? type : [type];
-  const v = value.trim();
-  if ((types.includes("integer") || types.includes("number")) && v !== "" && !Number.isNaN(Number(v))) return Number(v);
-  if (types.includes("boolean") && /^(true|false)$/i.test(v)) return v.toLowerCase() === "true";
-  if ((types.includes("object") || types.includes("array")) && /^[[{]/.test(v)) {
-    try {
-      return JSON.parse(v);
-    } catch {
-    }
-  }
-  return value.replace(/^\n+|\n+$/g, "");
-}
-function pickTool(name, keys, tools) {
-  const named = name && tools.find((t2) => t2.function.name === name);
-  if (named) return named;
-  let best;
-  let bestScore = 0;
-  let tie = false;
-  for (const t2 of tools) {
-    const params = t2.function.parameters;
-    const props = Object.keys(params.properties ?? {});
-    if (!(params.required ?? []).every((r) => keys.includes(r))) continue;
-    const score = keys.filter((k) => props.includes(k)).length;
-    if (score > bestScore) [best, bestScore, tie] = [t2, score, false];
-    else if (score === bestScore && score > 0) tie = true;
-  }
-  return tie ? void 0 : best;
-}
-function recoverTextToolCalls(text, tools) {
-  if (!/<\/arg_value>|<tool_call>/.test(text)) return null;
-  const starts = [...text.matchAll(CALL_START)].map((m) => m.index ?? 0);
-  const firstPair = text.search(PAIR);
-  const cut = Math.min(...[...starts, firstPair].filter((i) => i >= 0));
-  const bounds = starts.filter((i) => i >= cut);
-  if (!bounds.length || bounds[0] > cut) bounds.unshift(cut);
-  const toolCalls = [];
-  bounds.forEach((start, n) => {
-    const segment = text.slice(start, bounds[n + 1] ?? text.length);
-    const name = /<tool_call>\s*([A-Za-z_][\w.-]*)/.exec(segment)?.[1] ?? /Tool:\s*`?([A-Za-z_][\w.-]*)`?/.exec(segment)?.[1];
-    let args = [];
-    const flush = () => {
-      if (!args.length) return;
-      const keys = args.map(([k]) => k);
-      const tool = pickTool(name, keys, tools);
-      if (tool) {
-        const props = tool.function.parameters.properties ?? {};
-        const input = Object.fromEntries(args.filter(([k]) => k in props).map(([k, v]) => [k, coerce(v, props[k].type)]));
-        toolCalls.push({ id: `text_call_${toolCalls.length}`, name: tool.function.name, arguments: JSON.stringify(input) });
-      }
-      args = [];
-    };
-    for (const m of segment.matchAll(PAIR)) {
-      if (args.some(([k]) => k === m[1])) flush();
-      args.push([m[1], m[2]]);
-    }
-    flush();
-  });
-  if (!toolCalls.length) return null;
-  return { text: text.slice(0, cut).trim(), toolCalls };
-}
-
-// src/tools/index.ts
-import { z as z7 } from "zod";
-
-// src/tools/edit.ts
-import { readFile, writeFile } from "fs/promises";
-import { z } from "zod";
-
-// src/diff.ts
-import { structuredPatch } from "diff";
-function diffLines(oldText, newText) {
-  const patch = structuredPatch("a", "b", oldText, newText, "", "", { context: 2 });
-  const out = [];
-  for (const hunk of patch.hunks) {
-    let oldLine = hunk.oldStart;
-    let newLine = hunk.newStart;
-    for (const raw of hunk.lines) {
-      const text = raw.slice(1);
-      if (raw[0] === "-") out.push({ kind: "del", line: oldLine++, text });
-      else if (raw[0] === "+") out.push({ kind: "add", line: newLine++, text });
-      else if (raw[0] === " ") {
-        out.push({ kind: "ctx", line: newLine, text });
-        oldLine++;
-        newLine++;
-      }
-    }
-  }
-  return out;
-}
-function formatDiff(lines) {
-  const mark = { add: "+", del: "-", ctx: " " };
-  return lines.map((l) => `${String(l.line).padStart(5)} ${mark[l.kind]} ${l.text}`).join("\n");
-}
-
-// src/tools/paths.ts
-import { isAbsolute, resolve } from "path";
-function resolvePath(cwd, path) {
-  return isAbsolute(path) ? path : resolve(cwd, path);
-}
-function errorCode(error) {
-  return error.code ?? error.message;
-}
-
-// src/tools/edit.ts
-var schema = z.object({
-  path: z.string().describe("File path, relative to the project or absolute"),
-  old_string: z.string().describe("Exact text to replace; must be unique unless replace_all"),
-  new_string: z.string().describe("Replacement text"),
-  replace_all: z.boolean().optional().describe("Replace every occurrence")
-});
-function countOccurrences(haystack, needle) {
-  let count = 0;
-  for (let i = haystack.indexOf(needle); i !== -1; i = haystack.indexOf(needle, i + needle.length)) count++;
-  return count;
-}
-function applyEdit(content, input) {
-  if (input.old_string === input.new_string) {
-    return { output: "old_string and new_string are identical; nothing to change.", isError: true };
-  }
-  const eol = content.includes("\r\n") ? "\r\n" : "\n";
-  const toEol = (s) => s.replace(/\r?\n/g, eol);
-  const attempts = [[input.old_string, input.new_string]];
-  if (toEol(input.old_string) !== input.old_string) attempts.push([toEol(input.old_string), toEol(input.new_string)]);
-  for (const [oldText, newText] of attempts) {
-    const count = oldText ? countOccurrences(content, oldText) : 0;
-    if (count === 0) continue;
-    if (count > 1 && !input.replace_all) {
-      return {
-        output: `old_string appears ${count} times in ${input.path}. Add more context to make it unique, or use replace_all.`,
-        isError: true
-      };
-    }
-    return input.replace_all ? content.split(oldText).join(newText) : content.replace(oldText, () => newText);
-  }
-  return { output: `old_string not found in ${input.path}. Re-read the file.`, isError: true };
-}
-var editTool = defineTool({
-  name: "edit",
-  description: "Replace exact text in a file. The file must have been read first. old_string must match exactly (including indentation) and be unique unless replace_all is true.",
-  schema,
-  kind: "edit",
-  target: (input) => input.path,
-  async validate(input, ctx) {
-    const abs = resolvePath(ctx.cwd, input.path);
-    if (!ctx.readFiles.has(abs)) return `Read ${input.path} with read before editing it.`;
-    let content;
-    try {
-      content = await readFile(abs, "utf8");
-    } catch (error) {
-      return `Cannot read ${input.path}: ${errorCode(error)}`;
-    }
-    const next = applyEdit(content, input);
-    return typeof next === "string" ? void 0 : next.output;
-  },
-  async preview(input, ctx) {
-    const abs = resolvePath(ctx.cwd, input.path);
-    const content = await readFile(abs, "utf8");
-    const next = applyEdit(content, input);
-    return typeof next === "string" ? formatDiff(diffLines(content, next)) : void 0;
-  },
-  async run(input, ctx) {
-    const abs = resolvePath(ctx.cwd, input.path);
-    if (!ctx.readFiles.has(abs)) {
-      return { output: `Read ${input.path} with read before editing it.`, isError: true };
-    }
-    let content;
-    try {
-      content = await readFile(abs, "utf8");
-    } catch (error) {
-      return { output: `Cannot read ${input.path}: ${errorCode(error)}`, isError: true };
-    }
-    const next = applyEdit(content, input);
-    if (typeof next !== "string") return next;
-    await ctx.checkpoint?.(abs);
-    await writeFile(abs, next);
-    return { output: `Edited ${input.path}.`, display: formatDiff(diffLines(content, next)) };
-  }
-});
-
-// src/tools/fetch.ts
-import { lookup as dnsCbLookup } from "dns";
-import { lookup as dnsLookup } from "dns/promises";
-import { isIP } from "net";
-import { Agent, fetch as undiciFetch } from "undici";
-import { z as z2 } from "zod";
-var MAX_CHARS = 12e3;
-var FOCUS_CHUNKS = 3;
-var FOCUS_SIZE = 800;
-var CACHE_MAX = 16;
-var CACHE_TTL_MS = 15 * 6e4;
-var CACHE_MAX_CHARS = 2e6;
-var MAX_BYTES = 5 * 1024 * 1024;
-async function readCapped(res) {
-  const reader = res.body?.getReader();
-  if (!reader) return { text: "", truncated: false };
-  const chunks = [];
-  let size = 0;
-  for (; ; ) {
-    const { done, value } = await reader.read();
-    if (done) return { text: Buffer.concat(chunks).toString("utf8"), truncated: false };
-    size += value.length;
-    if (size > MAX_BYTES) {
-      chunks.push(value.subarray(0, value.length - (size - MAX_BYTES)));
-      await reader.cancel();
-      return { text: Buffer.concat(chunks).toString("utf8"), truncated: true };
-    }
-    chunks.push(value);
-  }
-}
-function htmlToText(html) {
-  return html.replace(/<(script|style|noscript)[\s\S]*?<\/\1>/gi, "").replace(/<(br|\/p|\/div|\/h[1-6]|\/li|\/tr)\s*\/?>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&").split("\n").map((l) => l.replace(/\s+/g, " ").trim()).filter(Boolean).join("\n");
-}
-function describeFetchError(error) {
-  const cause = error.cause;
-  const code = cause?.code ?? "";
-  const detail = cause?.message ?? error.message;
-  if (error.name === "TimeoutError") return "no response within 30 seconds";
-  if (code === "ENOTFOUND" || code === "EAI_AGAIN") return `${detail} \u2014 DNS could not find the host (typo, offline, or blocked by DNS/ISP)`;
-  if (/CERT|SELF_SIGNED|UNABLE_TO/.test(code)) {
-    return `${detail} \u2014 TLS certificate rejected; often caused by an antivirus or proxy that inspects HTTPS. Try running with NODE_OPTIONS=--use-system-ca`;
-  }
-  if (/ECONNRESET|ECONNREFUSED|ETIMEDOUT|EHOSTUNREACH|ENETUNREACH|UND_ERR_CONNECT_TIMEOUT|UND_ERR_SOCKET/.test(code)) {
-    return `${detail} \u2014 connection failed (firewall, proxy, or the site is blocked by the network)`;
-  }
-  return code ? `${detail} (${code})` : detail;
-}
-var tokensOf = (text) => Math.ceil(text.length / 4);
-function isPrivateHost(host) {
-  const h = host.toLowerCase().replace(/^\[|\]$/g, "");
-  if (h === "localhost" || /\.(local|internal|lan|localdomain|home\.arpa)$/.test(h)) return true;
-  if (h.includes(":")) return /^(::1?$|f[cd]|fe[89ab]|::ffff:)/.test(h);
-  const v4 = h.match(/^(\d+)\.(\d+)\.\d+\.\d+$/);
-  if (v4) {
-    const [a, b] = [Number(v4[1]), Number(v4[2])];
-    return a === 0 || a === 10 || a === 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 100 && b >= 64 && b <= 127;
-  }
-  return !h.includes(".");
-}
-var words = (s) => s.toLowerCase().match(/[\p{L}\p{N}]{2,}/gu) ?? [];
-function pinLookup(pinned) {
-  return (hostname, options, callback) => {
-    const opts = typeof options === "object" && options !== null ? options : {};
-    const family = typeof options === "number" ? options : opts.family;
-    const realDns = () => dnsCbLookup(hostname, typeof options === "number" ? { family: options } : opts, callback);
-    if (!pinned.length) return realDns();
-    const list = family ? pinned.filter((a) => a.family === family) : pinned;
-    if (!list.length) {
-      callback(Object.assign(new Error(`no pinned address for family ${family}`), { code: "ENOTFOUND" }), "");
-      return;
-    }
-    if (opts.all) callback(null, list);
-    else callback(null, list[0].address, list[0].family);
-  };
-}
-function pickRelevant(text, query, count = FOCUS_CHUNKS, size = FOCUS_SIZE) {
-  const chunks = [];
-  let cur = "";
-  for (const line of text.split("\n")) {
-    for (let i = 0; i < Math.max(line.length, 1); i += size) {
-      cur += `${line.slice(i, i + size)}
-`;
-      if (cur.length >= size) {
-        chunks.push(cur.trimEnd());
-        cur = "";
-      }
-    }
-  }
-  if (cur.trim()) chunks.push(cur.trimEnd());
-  const q = [...new Set(words(query))];
-  const docs = chunks.map(words);
-  const avg = docs.reduce((n, d) => n + d.length, 0) / (docs.length || 1) || 1;
-  const idf = q.map((t2) => {
-    const df = docs.filter((d) => d.includes(t2)).length;
-    return Math.log(1 + (docs.length - df + 0.5) / (df + 0.5));
-  });
-  const scored = docs.map((d, i) => ({
-    i,
-    score: q.reduce((sum, t2, k) => {
-      const tf = d.filter((w) => w === t2).length;
-      return sum + idf[k] * tf * 2.2 / (tf + 1.2 * (0.25 + 0.75 * d.length / avg));
-    }, 0)
-  })).filter((c) => c.score > 0).sort((a, b) => b.score - a.score).slice(0, count).sort((a, b) => a.i - b.i);
-  return scored.length ? scored.map((c) => chunks[c.i]).join("\n\u2026\n") : null;
-}
-var cache = /* @__PURE__ */ new Map();
-function remember(key, value, size) {
-  if (size > CACHE_MAX_CHARS) return;
-  cache.delete(key);
-  cache.set(key, value);
-  if (cache.size > CACHE_MAX) cache.delete(cache.keys().next().value);
-}
-function recall(key) {
-  const hit = cache.get(key);
-  if (typeof hit === "object" && Date.now() - hit.at > CACHE_TTL_MS) {
-    cache.delete(key);
-    return void 0;
-  }
-  return hit;
-}
-var ACCEPT = "text/markdown, text/html;q=0.9, text/plain;q=0.8, */*;q=0.5";
-var withCost = (text, what) => `${what} \xB7 ${t("~{n} tokens", { n: tokensOf(text) })}`;
-function createFetchTool(opts = {}) {
-  const keenableURL = opts.keenableURL === void 0 ? "https://api.keenable.ai/v1/fetch/public" : opts.keenableURL;
-  const isPrivate = opts.isPrivate ?? isPrivateHost;
-  const lookup = opts.lookup ?? ((hostname) => dnsLookup(hostname, { all: true }));
-  return defineTool({
-    name: "fetch",
-    description: `Fetch a URL (http/https) as text/markdown. Costs the user tokens, so ask for as little as you need:
-- Pass \`prompt\` (what you want to know from the page) to get only the relevant excerpt instead of the whole page. Prefer this whenever you are looking for specific facts.
-- Without \`prompt\` you get the first ${MAX_CHARS} characters; the reply tells you the \`offset\` to continue from.
-- Fetching a page that is already in this conversation is wasteful; reuse what you have.`,
-    schema: z2.object({
-      url: z2.string().describe("Absolute http(s) URL"),
-      prompt: z2.string().max(2e3).optional().describe("What to look for in the page; returns only the relevant excerpt"),
-      offset: z2.number().int().min(0).optional().describe("Start reading at this character (to continue a truncated page)")
-    }),
-    kind: "fetch",
-    target: (input) => input.url,
-    async run(input, ctx) {
-      if (!/^https?:\/\//i.test(input.url)) return { output: "URL must start with http:// or https://", isError: true };
-      const target = new URL(input.url);
-      let pinned;
-      if (!isPrivate(target.hostname) && isIP(target.hostname) === 0) {
-        try {
-          const addresses = await lookup(target.hostname);
-          const internal = addresses.find((a) => isPrivate(a.address));
-          if (internal) {
-            return {
-              output: t("Blocked: {host} resolves to a private address ({addr}). Fetching an internal host through a public DNS name is not allowed.", { host: target.hostname, addr: internal.address }),
-              isError: true
-            };
-          }
-          pinned = addresses;
-        } catch {
-        }
-      }
-      const prompt = input.prompt?.trim();
-      const askKeenable = !!prompt && !input.offset && !!keenableURL && !target.username && !target.password && !isPrivate(target.hostname);
-      if (askKeenable) {
-        const key = `x
-${input.url}
-${prompt}`;
-        const hit = recall(key);
-        if (hit) {
-          ctx.refundFetch?.();
-          return { output: hit, display: withCost(hit, t("focused excerpt \xB7 cache")) };
-        }
-        const out = await extractWithKeenable(keenableURL, input.url, prompt, ctx.signal);
-        if (out) {
-          const output2 = `[Excerpt from ${input.url} for "${prompt}" (extracted by Keenable). If it says the answer is not there, try fetch without a prompt.]
-${out}`;
-          remember(key, output2, output2.length);
-          return { output: output2, display: withCost(output2, t("focused excerpt (Keenable)")) };
-        }
-      }
-      let page = recall(`p
-${input.url}`);
-      const cached = !!page;
-      if (cached) ctx.refundFetch?.();
-      if (!page) {
-        const loaded = await loadPage(input.url, ctx.signal, pinned, opts.fetchPage);
-        if ("error" in loaded) return { output: loaded.error, isError: true };
-        page = loaded;
-        remember(`p
-${input.url}`, page, page.text.length);
-      }
-      const { text, truncated } = page;
-      const via = cached ? " \xB7 cache" : "";
-      if (prompt && !input.offset) {
-        const picked = pickRelevant(text, prompt);
-        if (picked) {
-          const output2 = `[Most relevant excerpt from ${input.url} for "${prompt}" (${text.length} characters total). Full page: fetch without a prompt.]
-${picked}`;
-          return { output: output2, display: withCost(output2, `${t("focused excerpt (local)")}${via}`) };
-        }
-      }
-      const offset = input.offset ?? 0;
-      if (offset >= text.length && text.length > 0) {
-        return { output: `offset ${offset} is past the end of the page (${text.length} characters).`, isError: true };
-      }
-      const end = Math.min(offset + MAX_CHARS, text.length);
-      let output = text.slice(offset, end);
-      if (end < text.length || truncated) {
-        const total = truncated ? `${text.length}+` : text.length;
-        output += `
-\u2026 [truncated: characters ${offset}-${end} of ${total}. Continue with offset=${end}, or use prompt for a focused excerpt.]`;
-      }
-      const size = truncated ? t("over 5 MB, truncated") : t("{n} characters", { n: text.length });
-      return { output, display: withCost(output, `${size}${via}`) };
-    }
-  });
-}
-async function extractWithKeenable(endpoint, url, prompt, signal) {
-  try {
-    const u = new URL(endpoint);
-    u.searchParams.set("url", url);
-    u.searchParams.set("prompt", prompt);
-    u.searchParams.set("live", "true");
-    u.searchParams.set("max_chars", String(MAX_CHARS));
-    const res = await fetch(u, { headers: { "X-Keenable-Title": "BotConnector" }, signal: AbortSignal.any([signal, AbortSignal.timeout(25e3)]) });
-    if (!res.ok) return void 0;
-    const content = (await res.json()).content;
-    return typeof content === "string" && content.trim() ? content.slice(0, MAX_CHARS) : void 0;
-  } catch {
-    return void 0;
-  }
-}
-async function loadPage(inputUrl, signal, pinned, fetchPage) {
-  let url = new URL(inputUrl);
-  const dispatcher = pinned?.length ? new Agent({ connect: { lookup: pinLookup(pinned) } }) : void 0;
-  const doFetch = fetchPage ?? (dispatcher ? undiciFetch : fetch);
-  try {
-    let res;
-    for (let hop = 0; hop < 5; hop++) {
-      res = await doFetch(url, {
-        headers: { accept: ACCEPT },
-        signal: AbortSignal.any([signal, AbortSignal.timeout(3e4)]),
-        redirect: "manual",
-        ...dispatcher ? { dispatcher } : {}
-      });
-      const location = res.status >= 300 && res.status < 400 ? res.headers.get("location") : null;
-      if (!location) break;
-      const next = new URL(location, url);
-      if (next.host !== url.host) {
-        await res.body?.cancel();
-        return { error: `Redirect to another host: ${next.href}. Call fetch again with that URL if needed (permission will be requested).` };
-      }
-      await res.body?.cancel();
-      url = next;
-    }
-    if (!res) return { error: `Failed to fetch ${inputUrl}` };
-    const { text: body, truncated } = await readCapped(res);
-    const type = res.headers.get("content-type") ?? "";
-    const text = type.includes("html") ? htmlToText(body) : body;
-    if (!res.ok) return { error: `HTTP ${res.status} from ${inputUrl}: ${text.slice(0, 500)}` };
-    return { text, truncated, at: Date.now() };
-  } catch (error) {
-    return { error: `Failed to fetch ${inputUrl}: ${describeFetchError(error)}` };
-  } finally {
-    await dispatcher?.close().catch(() => {
-    });
-  }
-}
-var fetchTool = createFetchTool();
-
-// src/tools/glob.ts
-import { glob as nativeGlob } from "fs/promises";
-import { z as z3 } from "zod";
-
-// src/abort.ts
-var ABORTED = /* @__PURE__ */ Symbol("aborted");
-function raceAbort(promise, signal) {
-  if (signal.aborted) return Promise.resolve(ABORTED);
-  return new Promise((resolve2, reject) => {
-    const onAbort = () => resolve2(ABORTED);
-    signal.addEventListener("abort", onAbort, { once: true });
-    promise.then(
-      (value) => {
-        signal.removeEventListener("abort", onAbort);
-        resolve2(value);
-      },
-      (error) => {
-        signal.removeEventListener("abort", onAbort);
-        reject(error);
-      }
-    );
-  });
-}
-async function collectUntilAbort(iterable, signal, onItem) {
-  const iterator = iterable[Symbol.asyncIterator]();
-  try {
-    for (; ; ) {
-      const next = signal ? await raceAbort(iterator.next(), signal) : await iterator.next();
-      if (next === ABORTED) return false;
-      if (next.done) return true;
-      onItem(next.value);
-    }
-  } finally {
-    Promise.resolve(iterator.return?.(void 0)).catch(() => {
-    });
-  }
-}
-
-// src/tools/glob.ts
-var MAX_OUTPUT_CHARS = 24e3;
-var globTool = defineTool({
-  name: "glob",
-  description: 'Find files by glob pattern, e.g. "src/**/*.ts". Respects .gitignore. Max 500 results.',
-  schema: z3.object({
-    pattern: z3.string().describe("Glob pattern"),
-    path: z3.string().optional().describe("Base directory, default project root")
-  }),
-  kind: "read",
-  target: (input) => input.pattern,
-  async run(input, ctx) {
-    const invalid = validateGlobPattern(input.pattern);
-    if (invalid) return { output: invalid, isError: true };
-    const root = resolvePath(ctx.cwd, input.path ?? ".");
-    const files = [];
-    const finished = await collectUntilAbort(
-      nativeGlob(input.pattern, { cwd: root, exclude: ignorePatterns(root) }),
-      ctx.signal,
-      (file) => files.push(normalizeGlobPath(file))
-    );
-    if (!finished) return { output: "Cancelled by the user.", isError: true };
-    files.sort();
-    if (!files.length) return { output: "No matching files." };
-    const first = files.slice(0, 500);
-    const shown = [];
-    let size = 0;
-    for (const file of first) {
-      const extra = file.length + (shown.length ? 1 : 0);
-      if (shown.length && size + extra > MAX_OUTPUT_CHARS) break;
-      shown.push(file);
-      size += extra;
-      if (size >= MAX_OUTPUT_CHARS) break;
-    }
-    const omitted = files.length - shown.length;
-    const more = omitted > 0 ? `
-\u2026 ${omitted} more files omitted (narrow pattern/path)` : "";
-    return { output: shown.join("\n") + more, display: `${files.length} file` };
-  }
-});
-
-// src/tools/grep.ts
-import { execFile } from "child_process";
-import { readFile as readFile2 } from "fs/promises";
-import { glob as nativeGlob2 } from "fs/promises";
-import { z as z4 } from "zod";
-var MAX_MATCHES = 200;
-var MAX_OUTPUT_CHARS2 = 24e3;
-async function grepJs(pattern, opts) {
-  const regex = new RegExp(pattern, opts.ignoreCase ? "i" : "");
-  const files = [];
-  const finished = await collectUntilAbort(
-    nativeGlob2(opts.glob ?? "**/*", { cwd: opts.root, exclude: ignorePatterns(opts.root) }),
-    opts.signal,
-    (file) => files.push(normalizeGlobPath(file))
-  );
-  const out = [];
-  if (!finished) return out;
-  for (const file of files.sort()) {
-    if (opts.signal?.aborted) break;
-    let text;
-    try {
-      const buffer = await readFile2(resolvePath(opts.root, file));
-      if (buffer.subarray(0, 8e3).includes(0)) continue;
-      text = buffer.toString("utf8");
-    } catch {
-      continue;
-    }
-    const lines = text.split(/\r?\n/);
-    for (let i = 0; i < lines.length && out.length < MAX_MATCHES; i++) {
-      if (regex.test(lines[i])) out.push(`${file}:${i + 1}:${lines[i].slice(0, 300)}`);
-    }
-    if (out.length >= MAX_MATCHES) break;
-  }
-  return out;
-}
-function grepRg(pattern, opts) {
-  const args = ["--line-number", "--no-heading", "--color", "never", "--max-columns", "300", "-e", pattern];
-  if (opts.ignoreCase) args.push("-i");
-  if (opts.glob) args.push("-g", opts.glob);
-  args.push(".");
-  return new Promise((resolve2) => {
-    execFile("rg", args, { cwd: opts.root, maxBuffer: 10 * 1024 * 1024, signal: opts.signal }, (error, stdout) => {
-      if (opts.signal?.aborted) return resolve2([]);
-      const code = error?.code;
-      if (code === "ENOENT") return resolve2(void 0);
-      if (error && error.code !== 1) return resolve2(void 0);
-      resolve2(stdout.split("\n").filter(Boolean).map((l) => l.replace(/^\.\//, "")).slice(0, MAX_MATCHES));
-    });
-  });
-}
-var grepTool = defineTool({
-  name: "grep",
-  description: "Search file contents with a regular expression. Respects .gitignore. Returns path:line:text (max 200).",
-  schema: z4.object({
-    pattern: z4.string().describe("Regular expression"),
-    path: z4.string().optional().describe("Directory to search, default project root"),
-    glob: z4.string().optional().describe('Only files matching this glob, e.g. "**/*.ts"'),
-    ignore_case: z4.boolean().optional()
-  }),
-  kind: "read",
-  target: (input) => input.pattern,
-  async run(input, ctx) {
-    if (input.glob) {
-      const invalid = validateGlobPattern(input.glob);
-      if (invalid) return { output: invalid, isError: true };
-    }
-    const opts = { root: resolvePath(ctx.cwd, input.path ?? "."), glob: input.glob, ignoreCase: input.ignore_case, signal: ctx.signal };
-    try {
-      new RegExp(input.pattern);
-    } catch (error) {
-      return { output: `Invalid regex: ${error.message}`, isError: true };
-    }
-    const matches = await grepRg(input.pattern, opts) ?? await grepJs(input.pattern, opts);
-    if (ctx.signal.aborted) return { output: "Cancelled by the user.", isError: true };
-    if (!matches.length) return { output: "No matches." };
-    const shown = [];
-    let size = 0;
-    for (const match of matches) {
-      const extra = match.length + (shown.length ? 1 : 0);
-      if (shown.length && size + extra > MAX_OUTPUT_CHARS2) break;
-      shown.push(match);
-      size += extra;
-      if (size >= MAX_OUTPUT_CHARS2) break;
-    }
-    const omitted = matches.length - shown.length;
-    const suffix = omitted > 0 ? `
-\u2026 ${omitted} more matches omitted (narrow pattern/path/glob)` : "";
-    return { output: shown.join("\n") + suffix, display: t("{n} results", { n: matches.length }) };
-  }
-});
-
-// src/tools/read.ts
-import { readFile as readFile3 } from "fs/promises";
-import { z as z5 } from "zod";
-var MAX_LINE = 2e3;
-var MAX_OUTPUT_CHARS3 = 4e4;
-var MAX_IMAGE_BYTES = 4 * 1024 * 1024;
-var IMAGE_HEADERS = [
-  {
-    mediaType: "image/png",
-    match: (h) => h.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))
-  },
-  { mediaType: "image/jpeg", match: (h) => h[0] === 255 && h[1] === 216 && h[2] === 255 },
-  { mediaType: "image/gif", match: (h) => h.subarray(0, 6).toString("ascii").startsWith("GIF8") },
-  {
-    mediaType: "image/webp",
-    match: (h) => h.subarray(0, 4).toString("ascii") === "RIFF" && h.subarray(8, 12).toString("ascii") === "WEBP"
-  }
-];
-var MEDIA_LABEL = {
-  "image/png": "png",
-  "image/jpeg": "jpeg",
-  "image/gif": "gif",
-  "image/webp": "webp"
-};
-function imageMediaType(buffer) {
-  return IMAGE_HEADERS.find((entry) => entry.match(buffer))?.mediaType;
-}
-var schema2 = z5.object({
-  path: z5.string().describe("File path, relative to the project or absolute"),
-  offset: z5.number().int().min(1).optional().describe("First line to read, 1-based"),
-  limit: z5.number().int().min(1).optional().describe("Number of lines, default 2000")
-});
-async function readImageResult(input, buffer, mediaType) {
-  if (buffer.length > MAX_IMAGE_BYTES) {
-    return {
-      output: `Cannot attach ${input.path}: image is ${(buffer.length / (1024 * 1024)).toFixed(1)} MB (limit 4 MB).`,
-      isError: true
-    };
-  }
-  const label = MEDIA_LABEL[mediaType] ?? mediaType;
-  return {
-    output: `[image attached] ${input.path} (${label}, ${(buffer.length / 1024).toFixed(1)} KB).`,
-    display: `${input.path} \xB7 image`,
-    images: [{ mediaType, data: buffer.toString("base64"), path: input.path }]
-  };
-}
-async function readTextResult(input, buffer) {
-  const lines = buffer.toString("utf8").split(/\r?\n/);
-  const start = (input.offset ?? 1) - 1;
-  const limit = input.limit ?? 2e3;
-  const requested = lines.slice(start, start + limit);
-  const shown = [];
-  let size = 0;
-  for (let i = 0; i < requested.length; i++) {
-    const line = requested[i];
-    const text = line.length > MAX_LINE ? `${line.slice(0, MAX_LINE)}\u2026 [line truncated]` : line;
-    const rendered = `${String(start + i + 1).padStart(6)}	${text}`;
-    const extra = rendered.length + (shown.length ? 1 : 0);
-    if (shown.length && size + extra > MAX_OUTPUT_CHARS3) break;
-    shown.push(rendered);
-    size += extra;
-    if (size >= MAX_OUTPUT_CHARS3) break;
-  }
-  const body = shown.join("\n");
-  const remaining = lines.length - start - shown.length;
-  const tokenBudgetHit = shown.length < requested.length;
-  const nextOffset = start + shown.length + 1;
-  return {
-    output: remaining > 0 ? tokenBudgetHit ? `${body}
-\u2026 ${remaining} more lines (token budget reached; continue with offset=${nextOffset})` : `${body}
-\u2026 ${remaining} more lines (use offset)` : body,
-    display: t("{n} lines", { n: shown.length })
-  };
-}
-function createReadTool(options = {}) {
-  const vision = options.vision !== false;
-  return defineTool({
-    name: "read",
-    description: vision ? "Read a text file, or an image (png/jpeg/gif/webp) which is attached for the model to see. Returns numbered lines (default first 2000). Use offset/limit for large files. Always read a file before editing it." : "Read a text file. Returns numbered lines (default first 2000). Use offset/limit for large files. Always read a file before editing it.",
-    schema: schema2,
-    kind: "read",
-    target: (input) => input.path,
-    async run(input, ctx) {
-      const abs = resolvePath(ctx.cwd, input.path);
-      let buffer;
-      try {
-        buffer = await readFile3(abs);
-      } catch (error) {
-        return { output: `Cannot read ${input.path}: ${errorCode(error)}`, isError: true };
-      }
-      const mediaType = vision ? imageMediaType(buffer) : void 0;
-      if (mediaType) {
-        ctx.readFiles.add(abs);
-        return readImageResult(input, buffer, mediaType);
-      }
-      if (buffer.subarray(0, 8e3).includes(0)) {
-        return { output: `${input.path} is a binary file; not read.`, isError: true };
-      }
-      ctx.readFiles.add(abs);
-      return readTextResult(input, buffer);
-    }
-  });
-}
-var readTool = createReadTool({ vision: true });
-
-// src/tools/write.ts
-import { existsSync } from "fs";
-import { mkdir, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
-import { dirname } from "path";
-import { z as z6 } from "zod";
-var writeTool = defineTool({
-  name: "write",
-  description: "Create or overwrite a file with the given content. Read an existing file first. Prefer edit for changes.",
-  schema: z6.object({
-    path: z6.string().describe("File path, relative to the project or absolute"),
-    content: z6.string().describe("Full new file content")
-  }),
-  kind: "edit",
-  target: (input) => input.path,
-  async validate(input, ctx) {
-    const abs = resolvePath(ctx.cwd, input.path);
-    return existsSync(abs) && !ctx.readFiles.has(abs) ? `${input.path} already exists. Read it with read before overwriting it.` : void 0;
-  },
-  async preview(input, ctx) {
-    const abs = resolvePath(ctx.cwd, input.path);
-    const old = existsSync(abs) ? await readFile4(abs, "utf8") : "";
-    return formatDiff(diffLines(old, input.content));
-  },
-  async run(input, ctx) {
-    const abs = resolvePath(ctx.cwd, input.path);
-    if (existsSync(abs) && !ctx.readFiles.has(abs)) {
-      return { output: `${input.path} already exists. Read it with read before overwriting it.`, isError: true };
-    }
-    try {
-      await ctx.checkpoint?.(abs);
-      await mkdir(dirname(abs), { recursive: true });
-      await writeFile2(abs, input.content);
-    } catch (error) {
-      return { output: `Failed to write ${input.path}: ${errorCode(error)}`, isError: true };
-    }
-    ctx.readFiles.add(abs);
-    const lines = input.content.split("\n").length;
-    return { output: `Wrote ${input.path} (${lines} lines).`, display: t("{lines} lines written", { lines }) };
-  }
-});
-
-// src/tools/index.ts
-var ALL_TOOLS = [readTool, writeTool, editTool, bashTool, grepTool, globTool, fetchTool];
-function toolDefinitions(tools) {
-  return tools.map((tool) => {
-    const { $schema: _ignored, ...parameters } = tool.jsonSchema ?? z7.toJSONSchema(tool.schema);
-    return { type: "function", function: { name: tool.name, description: tool.description, parameters, ...tool.outputJsonSchema ? { output_schema: tool.outputJsonSchema } : {} } };
-  });
-}
-
-// src/webBudget.ts
-var KEEP_TOKENS = 4e4;
-var PRUNE_MIN_TOKENS = 2e4;
-var STUB = "[old tool result removed:";
-var tokens = (text) => Math.ceil(text.length / 4);
-var isStub = (content) => content.startsWith(STUB);
-function pruneOldFetches(messages) {
-  const urls = /* @__PURE__ */ new Map();
-  for (const m of messages) {
-    if (m.role !== "assistant") continue;
-    for (const c of m.tool_calls ?? []) {
-      if (c.function.name !== "fetch") continue;
-      try {
-        urls.set(c.id, String(JSON.parse(c.function.arguments).url ?? ""));
-      } catch {
-        urls.set(c.id, "");
-      }
-    }
-  }
-  let kept = 0;
-  let oldTokens = 0;
-  const old = [];
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const m = messages[i];
-    if (m.role !== "tool" || !urls.has(m.tool_call_id) || isStub(m.content)) continue;
-    kept += tokens(m.content);
-    if (kept > KEEP_TOKENS) {
-      old.push(i);
-      oldTokens += tokens(m.content);
-    }
-  }
-  if (oldTokens <= PRUNE_MIN_TOKENS) return false;
-  for (const i of old) {
-    const m = messages[i];
-    messages[i] = { ...m, content: `${STUB} fetch ${urls.get(m.tool_call_id)}. Fetch it again (use prompt for a focused excerpt) if still needed.]` };
-  }
-  return true;
-}
-var WebBudget = class {
-  fetches = 0;
-  chars = 0;
-  perTurn;
-  sessionChars;
-  constructor(limits = {}) {
-    this.perTurn = limits.perTurn ?? 8;
-    this.sessionChars = limits.sessionChars ?? 3e5;
-  }
-  startTurn() {
-    this.fetches = 0;
-  }
-  /** Gives back a reservation, e.g. when the fetch was served from cache and cost nothing. */
-  refund() {
-    if (this.fetches > 0) this.fetches--;
-  }
-  reset() {
-    this.fetches = 0;
-    this.chars = 0;
-  }
-  /** Reserves one fetch; returns the refusal to show the model when over budget. */
-  take() {
-    if (this.fetches >= this.perTurn) {
-      return `Limit of ${this.perTurn} fetches per question reached (each fetch uses the user's tokens). Answer from the results you already have; if that is not enough, tell the user what is still missing.`;
-    }
-    if (this.chars >= this.sessionChars) {
-      return `Total web page limit for this session reached (~${Math.round(this.sessionChars / 4e3)}k tokens). Answer from the results you already have and ask the user whether to search more.`;
-    }
-    this.fetches++;
-    return void 0;
-  }
-  record(chars) {
-    this.chars += chars;
-  }
-};
-
-// src/tokenBudget.ts
-var estimateTokens = (text) => Math.ceil(text.length / 4);
-var estimateMessages = (messages) => estimateTokens(JSON.stringify(messages));
-function trimToFit(messages, maxTokens) {
-  let out = messages;
-  while (estimateMessages(out) > maxTokens) {
-    const boundary = out.findIndex((m, i) => i > 0 && m.role === "user");
-    if (boundary === -1) return out;
-    out = out.slice(boundary);
-  }
-  return out;
-}
-
-// src/agent.ts
-var CANCELLED = "Cancelled by the user.";
-var COMPACT_PROMPT = "Summarize the conversation so far for yourself so you can continue the work with no other context. Include: the user goals, decisions made, files touched and their current state, commands run and results, the task in progress and the next step. Be concise but complete.";
-var Agent2 = class {
-  constructor(opts) {
-    this.opts = opts;
-    this.provider = opts.provider;
-    this.permissions = opts.permissions;
-    this.tools = opts.tools;
-    this.definitions = toolDefinitions(opts.tools);
-    this.turnTools = this.tools;
-    this.turnDefinitions = this.definitions;
-    this.messages = [...opts.history ?? []];
-    this.maxSteps = typeof opts.maxSteps === "number" && Number.isFinite(opts.maxSteps) && opts.maxSteps > 0 ? Math.max(1, Math.floor(opts.maxSteps)) : void 0;
-    this.contextWindow = opts.contextWindow ?? 128e3;
-    this.systemPrompt = opts.systemPrompt;
-    this.reasoning = opts.reasoning ?? "auto";
-  }
-  opts;
-  provider;
-  permissions;
-  messages;
-  totalUsage = { inputTokens: 0, outputTokens: 0 };
-  lastInputTokens = 0;
-  onEvent = () => {
-  };
-  reasoning;
-  askPermission = async () => "no";
-  tools;
-  definitions;
-  // Snapshot for the running turn: tools added/removed mid-turn (e.g. an MCP server connecting) apply from the next turn.
-  turnTools;
-  turnDefinitions;
-  readFiles = /* @__PURE__ */ new Set();
-  webBudget = new WebBudget();
-  maxSteps;
-  // One window for every model; resolved from contextWindowFor() (catalog + env override).
-  contextWindow;
-  systemPrompt;
-  setSystemPrompt(text) {
-    this.systemPrompt = text;
-  }
-  setContextWindow(window) {
-    this.contextWindow = window;
-  }
-  setTools(tools) {
-    this.tools = tools;
-    this.definitions = toolDefinitions(tools);
-  }
-  isParallelSafe(call) {
-    const tool = this.turnTools.find((t2) => t2.name === call.name);
-    if (!tool?.parallelSafe) return false;
-    try {
-      const parsed = tool.schema.safeParse(JSON.parse(call.arguments || "{}"));
-      return parsed.success && tool.parallelSafe(parsed.data);
-    } catch {
-      return false;
-    }
-  }
-  push(message) {
-    this.messages.push(message);
-    this.opts.onMessage?.(message);
-  }
-  /** Swaps in another conversation (resume, new session) without writing to the session log. */
-  load(messages) {
-    this.messages = messages;
-    this.readFiles.clear();
-    this.webBudget.reset();
-    this.lastInputTokens = estimateMessages(messages) + estimateTokens(this.systemPrompt);
-  }
-  clear() {
-    this.messages = [];
-    this.readFiles.clear();
-    this.webBudget.reset();
-    this.lastInputTokens = 0;
-    this.opts.onReset?.();
-  }
-  async compact(signal) {
-    const history = trimToFit(this.messages, Math.floor(this.contextWindow * 0.8));
-    const completion = await this.provider.chat({
-      messages: [{ role: "system", content: this.systemPrompt }, ...history, { role: "user", content: COMPACT_PROMPT }],
-      // Some gateways reject tool_calls in history when no tools are declared.
-      tools: this.definitions,
-      signal,
-      reasoning: this.reasoning
-    });
-    this.clear();
-    this.push({ role: "user", content: `Summary of the previous conversation:
-${completion.text}` });
-    this.push({ role: "assistant", content: "OK, I will continue from this summary." });
-    this.onEvent({ type: "compacted" });
-  }
-  /**
-   * Events of one tool execution. A cancelled turn gives up on a tool that does not stop, and whatever that tool
-   * reports later must not reach the screen or a newer turn, so this is per execution and not per call id (ids repeat).
-   */
-  report(ticket, event) {
-    if (ticket.abandoned) return;
-    if (event.type === "toolStart") ticket.open = true;
-    if (event.type === "toolEnd") ticket.open = false;
-    this.onEvent(event);
-  }
-  async run(text, signal) {
-    this.turnTools = this.tools;
-    this.turnDefinitions = this.definitions;
-    this.opts.onTurnStart?.();
-    this.webBudget.startTurn();
-    try {
-      if (this.lastInputTokens > this.contextWindow * 0.8 && !hasPendingProgrammaticReplay(this.messages)) await this.compact(signal);
-      this.push({ role: "user", content: text });
-      for (let step = 0; this.maxSteps === void 0 || step < this.maxSteps; step++) {
-        if (step > 0 && this.lastInputTokens > this.contextWindow * 0.8 && !hasPendingProgrammaticReplay(this.messages)) {
-          await this.compact(signal);
-          this.push({ role: "user", content: `Continue this task using the summary above: ${text}` });
-        }
-        pruneOldFetches(this.messages);
-        let completion = await this.provider.chat({
-          messages: [{ role: "system", content: this.systemPrompt }, ...this.messages],
-          tools: this.turnDefinitions,
-          programmaticToolNames: this.turnTools.filter((tool) => tool.programmaticSafe).map((tool) => tool.name),
-          signal,
-          onText: (delta) => this.onEvent({ type: "text", delta }),
-          onThinking: (delta) => this.onEvent({ type: "thinking", delta }),
-          reasoning: this.reasoning
-        });
-        if (!completion.toolCalls.length && completion.finishReason !== "repetition") {
-          const recovered = recoverTextToolCalls(completion.text, this.turnDefinitions);
-          if (recovered) {
-            completion = { ...completion, ...recovered };
-            this.onEvent({ type: "textReplace", text: recovered.text });
-          }
-        }
-        const usage = completion.usage ?? {
-          inputTokens: estimateTokens(this.systemPrompt) + estimateTokens(JSON.stringify(this.messages)),
-          outputTokens: estimateTokens(completion.text) + (completion.toolCalls.length ? estimateTokens(JSON.stringify(completion.toolCalls)) : 0)
-        };
-        this.totalUsage.inputTokens += usage.inputTokens;
-        this.totalUsage.outputTokens += usage.outputTokens;
-        this.totalUsage.cachedInputTokens = (this.totalUsage.cachedInputTokens ?? 0) + (usage.cachedInputTokens ?? 0);
-        this.totalUsage.cacheWriteTokens = (this.totalUsage.cacheWriteTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
-        this.lastInputTokens = usage.inputTokens;
-        this.onEvent({ type: "usage", ...this.totalUsage });
-        this.push(completionAssistantMessage(completion));
-        if (completion.finishReason === "repetition") {
-          this.onEvent({ type: "textReplace", text: completion.text });
-          this.onEvent({
-            type: "error",
-            message: t("The model got stuck repeating text, so the answer was stopped. Try again or switch models with /model.")
-          });
-          return;
-        }
-        if (!completion.toolCalls.length) {
-          if (completion.finishReason === "continue") continue;
-          this.onEvent({ type: "done" });
-          return;
-        }
-        const calls = completion.toolCalls;
-        let i = 0;
-        const roundImages = [];
-        while (i < calls.length) {
-          if (signal.aborted) {
-            this.cancelCalls(calls.slice(i));
-            this.onEvent({ type: "aborted" });
-            return;
-          }
-          let j = i + 1;
-          if (this.isParallelSafe(calls[i])) while (j < calls.length && this.isParallelSafe(calls[j])) j++;
-          const batch = calls.slice(i, j);
-          const tickets = batch.map(() => ({ abandoned: false, open: false }));
-          const running = Promise.all(batch.map((c, k) => this.runTool(c, signal, tickets[k])));
-          const outcome = await raceAbort(running, signal);
-          if (outcome === ABORTED) {
-            batch.forEach((c, k) => {
-              const ticket = tickets[k];
-              ticket.abandoned = true;
-              if (ticket.open) this.onEvent({ type: "toolEnd", id: c.id, tool: c.name, output: CANCELLED, isError: true });
-            });
-            running.catch(() => {
-            });
-            this.cancelCalls(calls.slice(i));
-            this.onEvent({ type: "aborted" });
-            return;
-          }
-          batch.forEach((c, k) => {
-            roundImages.push(...outcome[k].images ?? []);
-            this.push({
-              role: "tool",
-              tool_call_id: c.id,
-              content: outcome[k].output,
-              ...c.caller ? { responses_caller: c.caller } : {}
-            });
-          });
-          i = j;
-        }
-        if (roundImages.length) this.push(imageUserMessage(roundImages));
-        if (signal.aborted) {
-          this.onEvent({ type: "aborted" });
-          return;
-        }
-      }
-      if (this.maxSteps !== void 0) this.onEvent({ type: "stepLimit", maxSteps: this.maxSteps });
-    } catch (error) {
-      if (signal.aborted) {
-        this.onEvent({ type: "aborted" });
-        return;
-      }
-      const message = error.message;
-      const noTools = error.status === 400 && /tool/i.test(message);
-      this.onEvent({
-        type: "error",
-        message: noTools ? `${message}
-${t("This model may not support tool calling. Try another model with /model.")}` : message
-      });
-    }
-  }
-  /** Every tool call needs an answer in the history, or the next request to the model is rejected. */
-  cancelCalls(calls) {
-    for (const pending of calls)
-      this.push({
-        role: "tool",
-        tool_call_id: pending.id,
-        content: CANCELLED,
-        ...pending.caller ? { responses_caller: pending.caller } : {}
-      });
-  }
-  /**
-   * Every tool call must resolve with text: a rejected one would leave the assistant tool_calls
-   * without answers, and the next request to the model would be rejected until a restart.
-   */
-  async runTool(call, signal, ticket) {
-    const emit = (event) => this.report(ticket, event);
-    try {
-      return await this.executeTool(call, signal, ticket);
-    } catch (error) {
-      const message = `Error: ${error?.message || String(error)}`;
-      if (ticket.open) {
-        emit({ type: "toolEnd", id: call.id, tool: call.name, output: message, isError: true });
-      } else {
-        emit({ type: "toolStart", id: call.id, tool: call.name, target: "" });
-        emit({ type: "toolEnd", id: call.id, tool: call.name, output: message, isError: true });
-      }
-      return { output: message };
-    }
-  }
-  async executeTool(call, signal, ticket) {
-    const emit = (event) => this.report(ticket, event);
-    const fail = (output, target2 = "") => {
-      emit({ type: "toolStart", id: call.id, tool: call.name, target: target2 });
-      emit({ type: "toolEnd", id: call.id, tool: call.name, output, isError: true });
-      return { output };
-    };
-    const tool = this.turnTools.find((t2) => t2.name === call.name);
-    if (!tool) return fail(`Tool "${call.name}" does not exist. Available tools: ${this.turnTools.map((t2) => t2.name).join(", ")}`);
-    let args;
-    try {
-      args = JSON.parse(call.arguments || "{}");
-    } catch {
-      return fail(`Arguments are not valid JSON: ${call.arguments.slice(0, 200)}`);
-    }
-    const parsed = tool.schema.safeParse(args);
-    if (!parsed.success) {
-      return fail(`Invalid arguments: ${parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ")}`);
-    }
-    const input = parsed.data;
-    const target = tool.target(input);
-    const overBudget = tool.name === "fetch" ? this.webBudget.take() : void 0;
-    if (overBudget) return fail(overBudget, target);
-    await this.opts.pluginEmit?.("PreToolUse", { tool: tool.name, input });
-    const pre = await runHooks(this.opts.hooks, "PreToolUse", { tool: tool.name, input }, { env: this.opts.env, cwd: this.opts.cwd });
-    if (pre.blocked) return fail(pre.blocked, target);
-    const ctx = {
-      cwd: this.opts.cwd,
-      signal,
-      readFiles: this.readFiles,
-      callId: call.id,
-      emit,
-      ask: (req) => this.askPermission(req),
-      checkpoint: this.opts.checkpoint,
-      refundFetch: () => this.webBudget.refund(),
-      addUsage: (u) => {
-        this.totalUsage.inputTokens += u.inputTokens;
-        this.totalUsage.outputTokens += u.outputTokens;
-        this.totalUsage.cachedInputTokens = (this.totalUsage.cachedInputTokens ?? 0) + (u.cachedInputTokens ?? 0);
-        this.totalUsage.cacheWriteTokens = (this.totalUsage.cacheWriteTokens ?? 0) + (u.cacheWriteTokens ?? 0);
-        this.onEvent({ type: "usage", ...this.totalUsage });
-      }
-    };
-    emit({ type: "toolStart", id: call.id, tool: tool.name, target });
-    const invalid = await tool.validate?.(input, ctx).catch((error) => error.message);
-    if (invalid) {
-      emit({ type: "toolEnd", id: call.id, tool: tool.name, output: invalid, isError: true });
-      return { output: invalid };
-    }
-    const request = { tool: tool.name, kind: tool.kind, target };
-    let decision = this.permissions.check(request);
-    if (decision === "ask") {
-      const preview = await tool.preview?.(input, ctx).catch(() => void 0);
-      const answer = await this.askPermission({
-        ...request,
-        preview,
-        sessionRules: this.permissions.rulesFor(request),
-        ...this.opts.label ? { agent: this.opts.label } : {}
-      });
-      if (answer === "session") this.permissions.allowForSession(request);
-      if (answer === "all") this.permissions.mode = "allowAll";
-      decision = answer === "no" ? "deny" : "allow";
-    }
-    if (decision === "deny") {
-      const output = this.permissions.mode === "plan" ? "Denied: plan mode only allows reading and searching. Write the plan for the user without changing anything." : "The user declined to run this tool. Ask the user what they want, or try another approach.";
-      emit({ type: "toolEnd", id: call.id, tool: tool.name, output, isError: true });
-      return { output };
-    }
-    let result;
-    try {
-      result = await tool.run(input, ctx);
-    } catch (error) {
-      result = { output: `Error: ${error.message}`, isError: true };
-    }
-    if (tool.name === "fetch" && !result.isError) this.webBudget.record(result.output.length);
-    await runHooks(
-      this.opts.hooks,
-      "PostToolUse",
-      { tool: tool.name, input, output: result.output },
-      { env: this.opts.env, cwd: this.opts.cwd }
-    );
-    await this.opts.pluginEmit?.("PostToolUse", { tool: tool.name, input, output: result.output });
-    emit({ type: "toolEnd", id: call.id, tool: tool.name, output: result.output, display: result.display, isError: !!result.isError });
-    return result;
-  }
-};
-
-// src/checkpoints.ts
-import { existsSync as existsSync2, statSync } from "fs";
-import { readFile as readFile5, rm, writeFile as writeFile3 } from "fs/promises";
-var MAX_TURNS = 20;
-var MAX_BYTES2 = 2 * 1024 * 1024;
-function emptyResult() {
-  return { restored: [], deleted: [], skipped: [], failed: [] };
-}
-async function restoreTurn(turn, result) {
-  for (const [path, original] of turn) {
-    try {
-      if (original === "skipped") result.skipped.push(path);
-      else if (original === null) {
-        await rm(path, { force: true });
-        result.deleted.push(path);
-      } else {
-        await writeFile3(path, original);
-        result.restored.push(path);
-      }
-    } catch {
-      result.failed.push(path);
-    }
-  }
-}
-var CheckpointStore = class {
-  history = [];
-  current;
-  beginTurn() {
-    if (this.current?.size === 0) return;
-    this.current = /* @__PURE__ */ new Map();
-    this.history.push(this.current);
-  }
-  /** Call before writing a file; only the first snapshot per file per turn is kept. */
-  async snapshot(path) {
-    if (!this.current) this.beginTurn();
-    const turn = this.current;
-    if (turn.has(path)) return;
-    if (!existsSync2(path)) turn.set(path, null);
-    else if (statSync(path).size > MAX_BYTES2) turn.set(path, "skipped");
-    else turn.set(path, await readFile5(path));
-    while (this.turns() > MAX_TURNS) this.history.shift();
-  }
-  turns() {
-    return this.history.filter((t2) => t2.size).length;
-  }
-  /** Total entries including empty ones; used to align file snapshots with conversation turns. */
-  entries() {
-    return this.history.length;
-  }
-  async undo() {
-    while (this.history.length && !this.history.at(-1)?.size) this.history.pop();
-    const turn = this.history.pop();
-    this.current = void 0;
-    if (!turn) return void 0;
-    const result = emptyResult();
-    await restoreTurn(turn, result);
-    return result;
-  }
-  /**
-   * Revert every snapshot taken at or after the `keep`-th entry, newest first, so the files
-   * end in the state from before the turn that created entry `keep`. Used by /rewind, which
-   * pairs conversation turns with the entry count recorded when each turn started.
-   */
-  async undoTo(keep) {
-    const target = Math.max(0, Math.min(keep, this.history.length));
-    const result = emptyResult();
-    let applied = false;
-    while (this.history.length > target) {
-      const turn = this.history.pop();
-      if (turn?.size) {
-        await restoreTurn(turn, result);
-        applied = true;
-      }
-    }
-    this.current = void 0;
-    return applied ? result : void 0;
-  }
-  clear() {
-    this.history.length = 0;
-    this.current = void 0;
-  }
-};
-
-// src/contextWindow.ts
-var DEFAULT_CONTEXT_WINDOW = 128e3;
-var WINDOWS = [
-  // BotConnector's Luna request cap (see LUNA_AUTO_COMPACT_THRESHOLD in provider.ts).
-  [/gpt-6-luna/i, 272e3],
-  [/claude-(opus|sonnet|haiku)-\d/i, 2e5],
-  [/gemini-\d/i, 1048576]
-];
-function contextWindowFor(modelRef, env = process.env) {
-  const override = Number(env.BCCLI_CONTEXT_WINDOW);
-  if (Number.isInteger(override) && override > 0) return override;
-  const model = modelRef.slice(modelRef.indexOf("/") + 1);
-  for (const [pattern, window] of WINDOWS) if (pattern.test(model)) return window;
-  return DEFAULT_CONTEXT_WINDOW;
-}
-
-// src/mcp/manager.ts
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { z as z8 } from "zod";
-var MCP_OUTPUT_MAX_CHARS = 32e3;
-var CHILD_ENV_KEYS = [
-  // portable
-  "PATH",
-  "HOME",
-  "USERPROFILE",
-  "LANG",
-  "LC_ALL",
-  "TZ",
-  "TMP",
-  "TEMP",
-  "TMPDIR",
-  // windows
-  "SYSTEMROOT",
-  "SYSTEMDRIVE",
-  "COMSPEC",
-  "PATHEXT",
-  "APPDATA",
-  "LOCALAPPDATA",
-  "HOMEDRIVE",
-  "HOMEPATH",
-  "USERNAME",
-  "PROGRAMFILES",
-  "PROCESSOR_ARCHITECTURE",
-  // posix
-  "LOGNAME",
-  "SHELL",
-  "TERM",
-  "USER"
-];
-function mcpChildEnv(extra) {
-  const env = {};
-  for (const key of CHILD_ENV_KEYS) {
-    const value = process.env[key];
-    if (value !== void 0) env[key] = value;
-  }
-  return { ...env, ...extra };
-}
-function mcpToolName(server, tool, taken) {
-  const clean2 = (s) => s.replace(/[^A-Za-z0-9_-]+/g, "_");
-  const base = `mcp__${clean2(server)}__${clean2(tool)}`.slice(0, 64);
-  let name = base;
-  for (let n = 2; taken.has(name); n++) name = `${base.slice(0, 64 - String(n).length - 1)}_${n}`;
-  taken.add(name);
-  return name;
-}
-function withTimeout(promise, ms) {
-  let timer;
-  const timeout = new Promise((_, reject) => {
-    timer = setTimeout(() => reject(new Error(t("timeout after {n} seconds", { n: Math.round(ms / 1e3) }))), ms);
-  });
-  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
-}
-var McpManager = class {
-  constructor(opts = {}) {
-    this.opts = opts;
-  }
-  opts;
-  servers = /* @__PURE__ */ new Map();
-  taken = /* @__PURE__ */ new Set();
-  async start(specs) {
-    await Promise.all(specs.map((spec) => this.add(spec)));
-  }
-  async add(spec) {
-    await this.remove(spec.name);
-    const entry = { spec, state: { name: spec.name, source: spec.source, status: "starting", tools: 0 }, tools: [] };
-    this.servers.set(spec.name, entry);
-    this.opts.onChange?.();
-    const client = new Client({ name: "bccli", version: "0.3.0" });
-    entry.client = client;
-    const timeoutMs = this.opts.connectTimeoutMs ?? 3e4;
-    try {
-      const config = expandEnvVars(spec.config, process.env);
-      let transport;
-      if (config.type === "http") {
-        const oauth = this.opts.home && (config.auth === "oauth" || hasStoredTokens(this.opts.home, config.url)) ? new FileOAuthProvider({ home: this.opts.home, serverUrl: config.url, open: this.opts.open }) : void 0;
-        transport = new StreamableHTTPClientTransport(new URL(config.url), {
-          requestInit: { headers: config.headers ?? {} },
-          ...oauth ? { authProvider: oauth } : {}
-        });
-      } else {
-        transport = new StdioClientTransport({
-          command: config.command,
-          args: config.args ?? [],
-          env: mcpChildEnv(config.env),
-          stderr: "ignore"
-        });
-      }
-      await withTimeout(client.connect(transport), timeoutMs);
-      const { tools } = await withTimeout(client.listTools(), timeoutMs);
-      if (this.servers.get(spec.name) !== entry) {
-        await client.close().catch(() => {
-        });
-        return;
-      }
-      entry.tools = tools.map((t2) => this.wrap(spec.name, client, t2));
-      entry.state = { ...entry.state, status: "ready", tools: entry.tools.length };
-    } catch (error) {
-      if (error instanceof UnauthorizedError) {
-        entry.state = {
-          ...entry.state,
-          status: "error",
-          error: t("OAuth required for {name}: run bccli mcp auth {name}", { name: spec.name })
-        };
-      } else {
-        entry.state = { ...entry.state, status: "error", error: error.message };
-      }
-      await client.close().catch(() => {
-      });
-      if (this.servers.get(spec.name) !== entry) return;
-    }
-    this.opts.onChange?.();
-  }
-  wrap(server, client, tool) {
-    return {
-      name: mcpToolName(server, tool.name, this.taken),
-      description: `[MCP ${server}] ${tool.description ?? tool.name}`.slice(0, 1024),
-      schema: z8.record(z8.string(), z8.unknown()),
-      jsonSchema: tool.inputSchema,
-      ...tool.outputSchema ? { outputJsonSchema: tool.outputSchema } : {},
-      kind: "mcp",
-      programmaticSafe: tool.annotations?.readOnlyHint === true,
-      target: (input) => {
-        const text = JSON.stringify(input);
-        return text.length > 80 ? `${text.slice(0, 77)}\u2026` : text;
-      },
-      async run(input, ctx) {
-        try {
-          const result = await client.callTool({ name: tool.name, arguments: input }, void 0, { signal: ctx.signal });
-          const output = (result.content ?? []).map((c) => c.type === "text" ? c.text ?? "" : `[${c.type}]`).join("\n") || "(empty)";
-          return {
-            output: output.length > MCP_OUTPUT_MAX_CHARS ? `${output.slice(0, MCP_OUTPUT_MAX_CHARS)}
-\u2026 [truncated at ${MCP_OUTPUT_MAX_CHARS} characters; narrow the MCP request if possible]` : output,
-            isError: !!result.isError
-          };
-        } catch (error) {
-          return { output: `Server MCP ${server} error: ${error.message}`, isError: true };
-        }
-      }
-    };
-  }
-  async remove(name) {
-    const entry = this.servers.get(name);
-    if (!entry) return;
-    this.servers.delete(name);
-    for (const t2 of entry.tools) this.taken.delete(t2.name);
-    if (entry.tools.length) this.opts.onToolsRemoved?.(entry.tools.map((t2) => t2.name));
-    await entry.client?.close().catch(() => {
-    });
-    this.opts.onChange?.();
-  }
-  tools() {
-    return [...this.servers.values()].flatMap((s) => s.tools).sort((a, b) => a.name.localeCompare(b.name));
-  }
-  states() {
-    return [...this.servers.values()].map((s) => s.state);
-  }
-  async stop() {
-    await Promise.all([...this.servers.keys()].map((name) => this.remove(name)));
-  }
-};
-
-// src/setup.ts
-import { homedir } from "os";
-
-// src/tools/plan.ts
-import { z as z9 } from "zod";
-function createExitPlanTool(opts) {
-  return defineTool({
-    name: "exit_plan",
-    description: "Plan mode only: present the finished plan to the user for approval. If approved you may start implementing it.",
-    schema: z9.object({ plan: z9.string().describe("The plan, in markdown") }),
-    kind: "read",
-    target: () => t("plan"),
-    async run(input) {
-      if (opts.permissions.mode !== "plan") return { output: "exit_plan is only used in plan mode.", isError: true };
-      const decision = await opts.interaction.approvePlan(input.plan);
-      if (decision === "no") {
-        return { output: "The user has not approved yet. Ask what needs to change, revise the plan, then call exit_plan again." };
-      }
-      opts.permissions.mode = decision;
-      return { output: `Plan approved. The mode is now ${decision}. Start carrying out the plan now.` };
-    }
-  });
-}
-
-// src/tools/skill.ts
-import { readFileSync } from "fs";
-import { z as z10 } from "zod";
-function createSkillTool(skills) {
-  return defineTool({
-    name: "skill",
-    description: "Load a skill (instructions for a kind of task) by name. Use it when a listed skill matches the task, then follow it.",
-    schema: z10.object({ name: z10.string().describe("Skill name from the list in the system prompt") }),
-    kind: "read",
-    target: (input) => input.name,
-    async run(input) {
-      const skill = skills.find((s) => s.name === input.name);
-      if (!skill) return { output: `Skill "${input.name}" does not exist. Available: ${skills.map((s) => s.name).join(", ") || "(none)"}`, isError: true };
-      const { body } = parseFrontmatter(readFileSync(skill.file, "utf8"));
-      return { output: `Base directory for this skill: ${skill.dir}
-
-${body}`, display: skill.description.slice(0, 60) };
-    }
-  });
-}
-
-// src/tools/websearch.ts
-import { z as z11 } from "zod";
-var clean = (items, max) => (Array.isArray(items) ? items : []).filter((r) => typeof r?.url === "string" && /^https?:\/\//.test(r.url)).slice(0, max).map((r) => ({
-  title: String(r.title || r.url).slice(0, 200),
-  url: r.url,
-  snippet: String(r.snippet || r.description || "").replace(/\s+/g, " ").trim().slice(0, 600)
-}));
-async function postJson(url, body, headers, signal) {
-  const res = await fetch(url, {
-    method: "POST",
-    headers: { "content-type": "application/json", ...headers },
-    body: JSON.stringify(body),
-    signal: AbortSignal.any([signal, AbortSignal.timeout(3e4)])
-  });
-  if (!res.ok) throw new Error(`HTTP ${res.status}`);
-  return res.json();
-}
-function createWebSearchTool(opts) {
-  const keenableURL = opts.keenableURL ?? "https://api.keenable.ai/v1/search/public";
-  return defineTool({
-    name: "web_search",
-    description: "Search the web. Returns titles, URLs and short snippets. Use it to find the right pages instead of guessing URLs; then fetch a result URL when you need the full page.",
-    schema: z11.object({
-      query: z11.string().min(1).max(500).describe("Search query"),
-      max_results: z11.number().int().min(1).max(10).optional().describe("Number of results (default 6)")
-    }),
-    kind: "read",
-    target: (input) => input.query,
-    parallelSafe: () => true,
-    async run(input, ctx) {
-      const max = input.max_results ?? 6;
-      const errors = [];
-      let results = [];
-      const bc = opts.botconnector();
-      if (bc) {
-        try {
-          const data = await postJson(`${bc.baseURL.replace(/\/+$/, "")}/web/search`, { query: input.query, max_results: max }, { authorization: `Bearer ${bc.apiKey}` }, ctx.signal);
-          results = clean(data.results, max);
-        } catch (error) {
-          errors.push(`BotConnector: ${error.message}`);
-        }
-      }
-      if (!results.length) {
-        try {
-          const data = await postJson(keenableURL, { query: input.query }, { "x-keenable-title": "BotConnector" }, ctx.signal);
-          results = clean(data.results, max);
-        } catch (error) {
-          errors.push(`Keenable: ${error.message}`);
-        }
-      }
-      if (!results.length) {
-        return { output: errors.length ? `Web search failed (${errors.join("; ")}).` : "No results.", isError: errors.length > 0 };
-      }
-      const output = results.map((r, i) => `${i + 1}. ${r.title}
-   ${r.url}${r.snippet ? `
-   ${r.snippet}` : ""}`).join("\n");
-      return { output, display: t("{n} results", { n: results.length }) };
-    }
-  });
-}
-
-// src/tools/task.ts
-import { z as z12 } from "zod";
-function createTaskTool(opts) {
-  const byName = new Map(opts.agents.map((a) => [a.name, a]));
-  const list = opts.agents.map((a) => `- ${a.name}: ${a.description}`).join("\n");
-  let askChain = Promise.resolve();
-  const enqueueAsk = (fn) => {
-    const next = askChain.then(
-      () => fn(),
-      () => fn()
-    );
-    askChain = next.then(
-      () => void 0,
-      () => void 0
-    );
-    return next;
-  };
-  return defineTool({
-    name: "task",
-    description: `Delegate a self-contained sub-task to a subagent. It starts with an empty context and returns only its final report. Available agents:
-${list}`,
-    schema: z12.object({
-      agent: z12.string().describe("Agent name"),
-      description: z12.string().describe("3-6 word summary shown to the user"),
-      prompt: z12.string().describe("Full instructions; the subagent sees nothing else")
-    }),
-    kind: "read",
-    target: (input) => `[${input.agent}] ${input.description}`,
-    // parallel: true opts a write-capable agent in; otherwise only all-read agents run concurrently
-    // (a project file may redefine "explore").
-    parallelSafe: (input) => {
-      const def = byName.get(input.agent);
-      if (def?.parallel) return true;
-      if (!def?.tools) return false;
-      const base = opts.baseTools();
-      return def.tools.every((name) => base.find((t2) => t2.name === name)?.kind === "read");
-    },
-    async run(input, ctx) {
-      const def = byName.get(input.agent);
-      if (!def) return { output: `Agent "${input.agent}" does not exist. Available: ${[...byName.keys()].join(", ")}`, isError: true };
-      const base = opts.baseTools().filter((t2) => t2.name !== "task" && t2.name !== "exit_plan");
-      const unknown = (def.tools ?? []).filter((n) => !base.some((t2) => t2.name === n));
-      if (unknown.length) return { output: `Agent "${def.name}": unknown tools: ${unknown.join(", ")}`, isError: true };
-      const allowed = def.tools;
-      const tools = allowed ? base.filter((t2) => allowed.includes(t2.name)) : base;
-      let provider;
-      try {
-        provider = def.model ? opts.providerFor(def.model) : opts.provider();
-      } catch (error) {
-        return { output: `Agent "${def.name}": ${error.message}`, isError: true };
-      }
-      const child = new Agent2({
-        provider,
-        tools,
-        permissions: opts.permissions,
-        systemPrompt: `${typeof opts.systemPrompt === "function" ? opts.systemPrompt(def.model) : opts.systemPrompt}
-
-# Your role
-${def.prompt}`,
-        cwd: opts.cwd,
-        // Every subagent runs with a step cap so a looping child cannot burn tokens forever.
-        maxSteps: def.maxSteps ?? 50,
-        label: def.name,
-        reasoning: opts.reasoning?.() ?? "auto",
-        hooks: opts.hooks,
-        pluginEmit: opts.pluginEmit,
-        env: opts.env,
-        // Subagent edits belong to the parent's turn so /undo reverts them too.
-        checkpoint: ctx.checkpoint
-      });
-      let outcome;
-      let steps = 0;
-      child.onEvent = (event) => {
-        if (event.type === "toolStart") steps++;
-        if (event.type === "error" || event.type === "stepLimit" || event.type === "aborted" || event.type === "done") outcome = event;
-        if (event.type !== "usage" && ctx.callId) ctx.emit?.({ type: "subagent", parentId: ctx.callId, agent: def.name, event });
-      };
-      const ask = ctx.ask;
-      if (ask) child.askPermission = (req) => enqueueAsk(() => ask(req));
-      await child.run(input.prompt, ctx.signal);
-      ctx.addUsage?.(child.totalUsage);
-      const tokens2 = child.totalUsage.inputTokens + child.totalUsage.outputTokens;
-      const display = t("{steps} steps \xB7 {tokens} tokens", { steps, tokens: tokens2 >= 1e3 ? `${Math.round(tokens2 / 1e3)}k` : tokens2 });
-      if (outcome?.type === "error") return { output: `Subagent ${def.name} failed: ${outcome.message}`, isError: true, display };
-      if (outcome?.type === "aborted") return { output: `Subagent ${def.name} was cancelled.`, isError: true, display };
-      const last = [...child.messages].reverse().find((m) => m.role === "assistant" && m.content);
-      const report = last && typeof last.content === "string" ? last.content : "(no report)";
-      const suffix = outcome?.type === "stepLimit" ? `
-
-(The subagent stopped at its ${outcome.maxSteps}-step limit.)` : "";
-      return { output: report + suffix, display };
-    }
-  });
-}
-
-// src/tools/todo.ts
-import { z as z13 } from "zod";
-var TodoStore = class {
-  items = [];
-  listeners = /* @__PURE__ */ new Set();
-  set(items) {
-    this.items = items;
-    for (const fn of this.listeners) fn(items);
-  }
-  subscribe(fn) {
-    this.listeners.add(fn);
-    return () => this.listeners.delete(fn);
-  }
-};
-function createTodoTool(store) {
-  return defineTool({
-    name: "todo_write",
-    description: "Write the task list for multi-step work (3+ steps). Send the whole list every time; exactly one item in_progress while working. Mark items completed as soon as they are done.",
-    schema: z13.object({
-      todos: z13.array(z13.object({ content: z13.string(), status: z13.enum(["pending", "in_progress", "completed"]) }))
-    }),
-    kind: "read",
-    target: (input) => `${input.todos.length} item`,
-    async run(input) {
-      if (input.todos.filter((t2) => t2.status === "in_progress").length > 1) {
-        return { output: "Only one item may be in_progress.", isError: true };
-      }
-      store.set(input.todos);
-      const done = input.todos.filter((t2) => t2.status === "completed").length;
-      return { output: `Todo updated: ${done}/${input.todos.length} completed.` };
-    }
-  });
-}
-
-// src/tools/memory.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { join } from "path";
-import { z as z14 } from "zod";
-function createSaveMemoryTool(opts) {
-  return defineTool({
-    name: "save_memory",
-    description: 'Save a durable fact, decision, or convention to the instruction files so future sessions remember it. Scope "project" (default) appends to AGENTS.md in the project; "global" appends to your personal BCCLI.md. Use for things worth remembering across sessions, not temporary task notes.',
-    schema: z14.object({
-      content: z14.string().min(1).max(500).describe("One short line, without a leading bullet (it is added for you)"),
-      scope: z14.enum(["project", "global"]).optional().describe("project (default) or global")
-    }),
-    kind: "edit",
-    target: (input) => `${input.scope ?? "project"} memory`,
-    async run(input, ctx) {
-      const content = input.content.trim();
-      if (!content) return { output: "Memory content is empty.", isError: true };
-      const file = input.scope === "global" ? join(opts.home, "BCCLI.md") : join(ctx.cwd, "AGENTS.md");
-      if (existsSync3(file)) {
-        const lines = readFileSync2(file, "utf8").split("\n");
-        if (lines.some((line) => line.trim() === `- ${content}`)) {
-          return { output: `Already saved to ${file}.` };
-        }
-      }
-      appendMemory(file, content);
-      opts.onSaved?.();
-      return { output: `Saved to ${file}.` };
-    }
-  });
-}
-
-// src/plugins.ts
-import { existsSync as existsSync4 } from "fs";
-import { createRequire } from "module";
-import { isAbsolute as isAbsolute2, join as join2 } from "path";
-import { z as z15 } from "zod";
-var require_ = createRequire(import.meta.url);
-function pluginLog(message) {
-  process.stderr.write(`[plugin] ${message}
-`);
-}
-function normalizeTool(def) {
-  return {
-    name: def.name,
-    description: def.description,
-    // Raw-args passthrough: a plugin without its own zod still receives what the model sent.
-    schema: def.schema ?? z15.record(z15.string(), z15.unknown()),
-    kind: def.kind ?? "read",
-    target: def.target ?? (() => def.name),
-    run: def.run
-  };
-}
-function loadPlugins(specs, opts) {
-  const tools = [];
-  const taken = new Set(opts.builtinNames);
-  const listeners = /* @__PURE__ */ new Map();
-  for (const spec of specs) {
-    let file;
-    try {
-      file = isAbsolute2(spec) ? spec : spec.startsWith(".") ? join2(opts.home, spec) : require_.resolve(spec);
-    } catch {
-      throw new ConfigError(t("Plugin not found: {spec}", { spec }));
-    }
-    if (!existsSync4(file)) throw new ConfigError(t("Plugin not found: {spec}", { spec }));
-    let mod;
-    try {
-      mod = require_(file);
-    } catch (error) {
-      throw new ConfigError(t("Plugin failed to load: {spec}: {reason}", { spec, reason: error.message }));
-    }
-    const activate = typeof mod.default === "function" ? mod.default : typeof mod.activate === "function" ? mod.activate : void 0;
-    if (!activate) {
-      throw new ConfigError(t("Plugin failed to load: {spec}: {reason}", { spec, reason: "no default or activate export" }));
-    }
-    const ctx = {
-      cwd: opts.cwd,
-      env: opts.env,
-      config: opts.config,
-      registerTool(tool) {
-        if (taken.has(tool.name)) {
-          throw new ConfigError(
-            t("Plugin {spec} registered a tool name that is already in use: {name}", { spec, name: tool.name })
-          );
-        }
-        taken.add(tool.name);
-        tools.push(normalizeTool(tool));
-      },
-      on(event, handler) {
-        const list = listeners.get(event) ?? [];
-        list.push(handler);
-        listeners.set(event, list);
-      },
-      log: pluginLog
-    };
-    try {
-      const result = activate(ctx);
-      if (result && typeof result.catch === "function") {
-        ;
-        result.catch((error) => pluginLog(`activation error in ${spec}: ${String(error)}`));
-      }
-    } catch (error) {
-      throw new ConfigError(t("Plugin failed to load: {spec}: {reason}", { spec, reason: error.message }));
-    }
-  }
-  return {
-    tools,
-    async emit(event, payload = {}) {
-      for (const handler of listeners.get(event) ?? []) {
-        try {
-          await handler(payload);
-        } catch (error) {
-          pluginLog(`handler for ${event} failed: ${String(error)}`);
-        }
-      }
-    }
-  };
-}
-
-// src/setup.ts
-var TOOL_RULES = { bash: "bash", edit: "edit", write: "edit", fetch: "fetch" };
-function lunaPtcAutoEnabled(env) {
-  const value = String(env.BCCLI_LUNA_PTC ?? "").trim().toLowerCase();
-  return !["0", "false", "off", "no"].includes(value);
-}
-function createRuntime(opts) {
-  const env = opts.env ?? process.env;
-  const home = bccliHome(env);
-  let config = loadConfig(opts.cwd, env);
-  let modelRef = opts.args.model ?? config.model;
-  let reasoning = opts.args.reasoning ?? config.reasoning;
-  const makeProvider = (ref) => {
-    const resolved = resolveModel(config, ref, env);
-    return opts.provider ?? createProvider({
-      baseURL: resolved.baseURL,
-      apiKey: resolved.apiKey,
-      model: resolved.model,
-      providerId: resolved.providerId,
-      enableProgrammaticToolCalling: lunaPtcAutoEnabled(env)
-    });
-  };
-  const provider = makeProvider(modelRef);
-  const mode = opts.args.allowAll ? "allowAll" : opts.args.permissionMode ?? config.permissionMode;
-  const rules = [...config.allow, ...opts.args.allowedTools.map((t2) => TOOL_RULES[t2] ?? t2)];
-  const permissions = new Permissions(mode, rules, opts.cwd);
-  const roots = { cwd: opts.cwd, home, userHome: opts.userHome ?? homedir() };
-  const skills = loadSkills(roots);
-  const commands = loadCommands(roots);
-  const agentDefs = loadAgentDefs(roots);
-  const todos = new TodoStore();
-  const checkpoints = new CheckpointStore();
-  const turnMarks = [];
-  const checkpointMarks = [];
-  let startedAt = /* @__PURE__ */ new Date();
-  const interaction = { approvePlan: async () => "no" };
-  let session = Session.create(home, opts.cwd);
-  let history = opts.history;
-  if (!history && opts.args.continue) {
-    const latest = Session.latest(home, opts.cwd);
-    if (latest) {
-      session = latest;
-      history = latest.load();
-    }
-  }
-  const systemPrompt = buildSystemPrompt({ cwd: opts.cwd, home, model: modelRef, skills });
-  const webSearch = createWebSearchTool({
-    botconnector: () => {
-      try {
-        const bc = resolveModel(config, "bc-cloud/search", env);
-        return bc.apiKey ? { baseURL: bc.baseURL, apiKey: bc.apiKey } : void 0;
-      } catch {
-        return void 0;
-      }
-    }
-  });
-  const rebuildPrompt = () => agent.setSystemPrompt(buildSystemPrompt({ cwd: opts.cwd, home, model: modelRef, skills }));
-  const saveMemory = createSaveMemoryTool({ home, onSaved: rebuildPrompt });
-  const baseTools = [
-    createReadTool({ vision: config.vision }),
-    createBashTool({ networkPolicy: config.networkPolicy }),
-    ...ALL_TOOLS.filter((tool) => tool.name !== "read" && tool.name !== "bash"),
-    webSearch,
-    createSkillTool(skills),
-    createTodoTool(todos),
-    createExitPlanTool({ permissions, interaction }),
-    saveMemory
-  ];
-  const plugins = loadPlugins(config.plugins ?? [], {
-    home,
-    cwd: opts.cwd,
-    env,
-    config,
-    builtinNames: [...baseTools.map((tool) => tool.name), "task"]
-  });
-  baseTools.push(...plugins.tools);
-  const pluginEmit = (event, payload) => plugins.emit(event, payload);
-  const task = createTaskTool({
-    agents: [...BUILTIN_AGENTS, ...agentDefs],
-    // Subagents get whatever the main agent has right now (incl. MCP tools), minus task itself.
-    baseTools: () => agent.tools.filter((t2) => t2.name !== "task"),
-    permissions,
-    provider: () => agent.provider,
-    providerFor: makeProvider,
-    systemPrompt: (childModelRef) => buildSystemPrompt({ cwd: opts.cwd, home, model: childModelRef ?? modelRef, skills }),
-    cwd: opts.cwd,
-    reasoning: () => reasoning,
-    hooks: config.hooks,
-    pluginEmit,
-    env
-  });
-  const agent = new Agent2({
-    provider,
-    tools: [...baseTools, task],
-    permissions,
-    systemPrompt,
-    cwd: opts.cwd,
-    history,
-    reasoning,
-    maxSteps: config.maxSteps,
-    hooks: config.hooks,
-    pluginEmit,
-    env,
-    contextWindow: contextWindowFor(modelRef, env),
-    onMessage: (m) => session.append(m),
-    onReset: () => session.reset(),
-    onTurnStart: () => {
-      for (let i = turnMarks.length - 1; i >= 0 && turnMarks[i] > agent.messages.length; i--) {
-        turnMarks.splice(i, 1);
-        checkpointMarks.splice(i, 1);
-      }
-      turnMarks.push(agent.messages.length);
-      checkpointMarks.push(checkpoints.entries());
-      checkpoints.beginTurn();
-    },
-    checkpoint: (path) => checkpoints.snapshot(path)
-  });
-  const mcp = new McpManager({
-    home,
-    onChange: () => agent.setTools([...baseTools, task, ...mcp.tools()]),
-    // A later server may reuse a sanitized name; it must not inherit this one's "[a]" grants.
-    onToolsRemoved: (names) => {
-      for (const name of names) permissions.revoke(`mcp(${name})`);
-    }
-  });
-  return {
-    cwd: opts.cwd,
-    home,
-    env,
-    skills,
-    commands,
-    agentDefs,
-    todos,
-    interaction,
-    mcp,
-    startMcp: (specs) => mcp.start(specs),
-    get config() {
-      return config;
-    },
-    reloadConfig() {
-      config = loadConfig(opts.cwd, env);
-    },
-    providerLabel() {
-      return providerName(config, modelRef.slice(0, modelRef.indexOf("/")));
-    },
-    listModels: (only) => listAllModels(config, env, { fetch: opts.fetch, only }),
-    addProviderKey(id, key) {
-      return addProviderKey(id, key, { env, cwd: opts.cwd, out: () => {
-      }, err: () => {
-      }, readSecret: async () => "", fetch: opts.fetch });
-    },
-    get modelRef() {
-      return modelRef;
-    },
-    get reasoning() {
-      return reasoning;
-    },
-    agent,
-    get session() {
-      return session;
-    },
-    resume(previous) {
-      session = previous;
-      agent.load(previous.load());
-      agent.totalUsage = { inputTokens: 0, outputTokens: 0 };
-      todos.set([]);
-      checkpoints.clear();
-      turnMarks.length = 0;
-      checkpointMarks.length = 0;
-    },
-    newSession() {
-      session = Session.create(home, opts.cwd);
-      agent.load([]);
-      agent.totalUsage = { inputTokens: 0, outputTokens: 0 };
-      todos.set([]);
-      checkpoints.clear();
-      turnMarks.length = 0;
-      checkpointMarks.length = 0;
-      startedAt = /* @__PURE__ */ new Date();
-    },
-    rebuildSystemPrompt() {
-      rebuildPrompt();
-    },
-    emitPlugins: (event, payload) => plugins.emit(event, payload),
-    checkpoints,
-    async rewindTurns(n) {
-      if (turnMarks.length === 0) return void 0;
-      const count = Math.min(Math.max(1, Math.floor(n) || 1), turnMarks.length);
-      const from = turnMarks.length - count;
-      const messageTarget = turnMarks[from];
-      const checkpointTarget = checkpointMarks[from];
-      turnMarks.splice(from);
-      checkpointMarks.splice(from);
-      const files = await checkpoints.undoTo(checkpointTarget);
-      const kept = agent.messages.slice(0, Math.min(messageTarget, agent.messages.length));
-      agent.load(kept);
-      session.reset();
-      for (const message of kept) session.append(message);
-      return {
-        turns: count,
-        restored: files?.restored ?? [],
-        deleted: files?.deleted ?? [],
-        skipped: files?.skipped ?? [],
-        failed: files?.failed ?? []
-      };
-    },
-    get startedAt() {
-      return startedAt;
-    },
-    setModel(ref) {
-      const nextProvider = makeProvider(ref);
-      modelRef = ref;
-      agent.provider = nextProvider;
-      agent.setContextWindow(contextWindowFor(ref, env));
-      agent.setSystemPrompt(buildSystemPrompt({ cwd: opts.cwd, home, model: modelRef, skills }));
-    },
-    setReasoning(level) {
-      reasoning = level;
-      agent.reasoning = level;
-    }
-  };
-}
-
-// src/version.ts
-var VERSION = true ? "0.4.0-beta.38" : "0.0.0-dev";
+} from "./chunk-M23QBX3V.js";
 
 // src/cli.ts
 function chooseLanguage(argv) {
@@ -2127,17 +66,17 @@ async function main() {
   if (args.worktree) cwd = (await resolveWorktree(cwd, args.worktree)).path;
   if (args.command === "login") return runLogin(args.loginProvider ?? "bc-cloud", cwd);
   if (args.command === "mcp") {
-    const { runMcpCommand } = await import("./mcpCli-5ZSAMBJS.js");
-    const { readSecret } = await import("./login-THRU4U4L.js");
+    const { runMcpCommand } = await import("./mcpCli-5QTXH7XJ.js");
+    const { readSecret } = await import("./login-IWBRUNT4.js");
     return runMcpCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s), readSecret });
   }
   if (args.command === "provider") {
-    const { runProviderCommand } = await import("./providerCli-TGDE3633.js");
-    const { readSecret } = await import("./login-THRU4U4L.js");
+    const { runProviderCommand } = await import("./providerCli-DDH4ZZUY.js");
+    const { readSecret } = await import("./login-IWBRUNT4.js");
     return runProviderCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s), readSecret });
   }
   if (args.command === "connect" || args.command === "disconnect" || args.command === "integrations") {
-    const { runIntegrationCommand } = await import("./integrationCli-ZTZTQD2I.js");
+    const { runIntegrationCommand } = await import("./integrationCli-HR7CDUSI.js");
     return runIntegrationCommand(args, {
       env: process.env,
       cwd,
@@ -2147,20 +86,41 @@ async function main() {
     });
   }
   if (args.command === "models") {
-    const config = loadConfig(cwd);
-    const resolved = resolveModel(config, args.model ?? config.model);
-    const models = await createProvider(resolved).listModels();
-    console.log(models.map((m) => `${resolved.providerId}/${m}`).join("\n"));
+    const { runModelsCommand } = await import("./modelsCli-DKTT3UZD.js");
+    return runModelsCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s), fetch: globalThis.fetch });
+  }
+  if (args.command === "update") {
+    const { runUpdateCommand } = await import("./update-73WI27VM.js");
+    return runUpdateCommand({ env: process.env });
+  }
+  if (args.command === "acp") {
+    const { runtimeAgent, runAcp } = await import("./acp-4XE2KOIJ.js");
+    await runAcp(process.stdin, process.stdout, { cwd, newAgent: (c) => runtimeAgent(c) });
+    return 0;
+  }
+  if (args.command === "serve") {
+    const { startServe } = await import("./serve-7BP5BVX3.js");
+    const handle = await startServe({ port: args.port, host: args.host, token: args.token, cwd, env: process.env });
+    process.stderr.write(`bccli serve ${handle.url} \u2014 Authorization: Bearer ${handle.token}
+`);
+    await new Promise((resolve) => {
+      const stop = () => {
+        void handle.close().finally(resolve);
+      };
+      process.once("SIGINT", stop);
+      process.once("SIGTERM", stop);
+    });
     return 0;
   }
   const rt = createRuntime({ cwd, args });
+  setTheme(rt.config.theme);
   try {
     pruneSessions(rt.home);
   } catch {
   }
   if (args.print) {
     if (!args.prompt) throw new ConfigError(t('-p mode needs a task, e.g. bccli -p "explain this repo"'));
-    const { serversToStart } = await import("./config-JRO5EOKZ.js");
+    const { serversToStart } = await import("./config-C4KLLDC6.js");
     const plan = serversToStart(rt.home, cwd);
     for (const s of plan.needTrust) {
       console.error(t('Project MCP server "{name}" skipped (not approved yet; run interactive bccli once to approve it).', { name: s.name }));
@@ -2173,7 +133,15 @@ async function main() {
     }
   }
   if (!process.stdin.isTTY) throw new ConfigError(t('Interactive mode needs a terminal. For scripts/CI use: bccli -p "task"'));
-  const { startInteractive } = await import("./ui-W4C6SRHA.js");
+  if (rt.config.updateCheck !== "off" && !process.env.BCCLI_NO_UPDATE_CHECK) {
+    try {
+      const { checkForUpdate } = await import("./update-73WI27VM.js");
+      const update = await checkForUpdate({ home: rt.home, fetch: globalThis.fetch, now: /* @__PURE__ */ new Date() });
+      if (update) console.error(update);
+    } catch {
+    }
+  }
+  const { startInteractive } = await import("./ui-MLOXPAHT.js");
   return startInteractive(rt, { initialPrompt: args.prompt, resume: args.resume, version: VERSION });
 }
 main().then(