@botconnector/bccli 0.4.0-beta.9 → 0.4.1

package/dist/chunk-PZRKU4UM.js

@@ -0,0 +1,2143 @@
+#!/usr/bin/env node
+import {
+  estimateMessages,
+  estimateTokens,
+  pruneOldToolOutputs,
+  splitKeepRecent,
+  trimToFit
+} from "./chunk-QZKLZELZ.js";
+import {
+  BUILTIN_AGENTS,
+  appendMemory,
+  bashTool,
+  buildSystemPrompt,
+  createBashTool,
+  ignorePatterns,
+  loadAgentDefs,
+  loadCommands,
+  loadSkills,
+  normalizeGlobPath,
+  parseFrontmatter,
+  runHooks,
+  validateGlobPattern
+} from "./chunk-BGXNR74O.js";
+import {
+  createWebSearchTool,
+  fetchTool
+} from "./chunk-45SDLMTV.js";
+import {
+  defineTool
+} from "./chunk-PSO7R5AD.js";
+import {
+  Permissions
+} from "./chunk-MHIYLXJC.js";
+import {
+  addProviderKey
+} from "./chunk-GN4W3T6E.js";
+import {
+  listAllModels
+} from "./chunk-75BECX4F.js";
+import {
+  providerName
+} from "./chunk-JHPGOAXU.js";
+import {
+  FileOAuthProvider,
+  hasStoredTokens
+} from "./chunk-MFHCQQEN.js";
+import {
+  Session
+} from "./chunk-BC7UXFE4.js";
+import {
+  completionAssistantMessage,
+  createProvider,
+  hasPendingProgrammaticReplay,
+  imageUserMessage
+} from "./chunk-WNACAUDK.js";
+import {
+  expandEnvVars
+} from "./chunk-24JN75FZ.js";
+import {
+  ConfigError,
+  bccliHome,
+  loadConfig,
+  resolveModel
+} from "./chunk-FLQPE4S5.js";
+import {
+  t
+} from "./chunk-UZWJQF67.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 z6 } 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/glob.ts
+import { glob as nativeGlob } from "fs/promises";
+import { z as z2 } 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: z2.object({
+    pattern: z2.string().describe("Glob pattern"),
+    path: z2.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 z3 } 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: z3.object({
+    pattern: z3.string().describe("Regular expression"),
+    path: z3.string().optional().describe("Directory to search, default project root"),
+    glob: z3.string().optional().describe('Only files matching this glob, e.g. "**/*.ts"'),
+    ignore_case: z3.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 z4 } 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 = z4.object({
+  path: z4.string().describe("File path, relative to the project or absolute"),
+  offset: z4.number().int().min(1).optional().describe("First line to read, 1-based"),
+  limit: z4.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 z5 } 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: z5.object({
+    path: z5.string().describe("File path, relative to the project or absolute"),
+    content: z5.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 ?? z6.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/budget.ts
+function priceFor(cap, model) {
+  if (!cap.prices) return void 0;
+  const key = Object.keys(cap.prices).find((k) => model.includes(k));
+  return key ? cap.prices[key] : void 0;
+}
+function budgetStatus(usage, cap, model) {
+  if (!cap) return void 0;
+  const total = usage.inputTokens + usage.outputTokens;
+  if (cap.tokens !== void 0 && total >= cap.tokens) return { kind: "tokens", used: total, limit: cap.tokens };
+  if (cap.usd !== void 0) {
+    const price = priceFor(cap, model);
+    if (price) {
+      const usd = (usage.inputTokens * price.input + usage.outputTokens * price.output) / 1e6;
+      if (usd >= cap.usd) return { kind: "usd", used: usd, limit: cap.usd };
+    }
+  }
+  return void 0;
+}
+
+// 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 Agent = 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) {
+    pruneOldToolOutputs(this.messages);
+    const keepTokens = Math.min(15e3, Math.floor(this.contextWindow * 0.1));
+    const [older, keep] = splitKeepRecent(this.messages, keepTokens);
+    const history = trimToFit(older, Math.floor(this.contextWindow * 0.8));
+    const pending = 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
+    });
+    const completion = await raceAbort(pending, signal);
+    if (completion === ABORTED) throw new Error("aborted");
+    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." });
+    for (const m of keep) this.push(m);
+    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 {
+      const over0 = this.overBudget();
+      if (over0) {
+        this.onEvent({ type: "budgetExceeded", ...over0 });
+        return;
+      }
+      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);
+        const over = this.overBudget();
+        if (over) {
+          this.onEvent({ type: "budgetExceeded", ...over });
+          return;
+        }
+        const pendingCompletion = 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,
+          // Late output from a cancelled provider must not leak into the next turn.
+          onText: (delta) => {
+            if (!signal.aborted) this.onEvent({ type: "text", delta });
+          },
+          onThinking: (delta) => {
+            if (!signal.aborted) this.onEvent({ type: "thinking", delta });
+          },
+          reasoning: this.reasoning
+        });
+        const outcome = await raceAbort(pendingCompletion, signal);
+        if (outcome === ABORTED) {
+          this.onEvent({ type: "aborted" });
+          return;
+        }
+        let completion = outcome;
+        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.opts.onUsage?.(usage);
+        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 outcome2 = await raceAbort(running, signal);
+          if (outcome2 === 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(...outcome2[k].images ?? []);
+            this.push({
+              role: "tool",
+              tool_call_id: c.id,
+              content: outcome2[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
+      });
+    }
+  }
+  /** Current cap status; undefined means the budget is not exhausted. */
+  overBudget() {
+    return budgetStatus(this.totalUsage, this.opts.usageCap, this.opts.budgetModel ?? "");
+  }
+  /** 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 });
+        this.opts.onUsage?.(u);
+      }
+    };
+    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_BYTES = 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;
+  pendingRedo;
+  beginTurn() {
+    if (this.current?.size === 0) return;
+    this.current = /* @__PURE__ */ new Map();
+    this.history.push(this.current);
+    this.pendingRedo = void 0;
+  }
+  /** 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_BYTES) 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();
+    const redo = /* @__PURE__ */ new Map();
+    await this.captureFor(turn, redo);
+    await restoreTurn(turn, result);
+    this.pendingRedo = redo;
+    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();
+    const redo = /* @__PURE__ */ new Map();
+    let applied = false;
+    while (this.history.length > target) {
+      const turn = this.history.pop();
+      if (turn?.size) {
+        await this.captureFor(turn, redo);
+        await restoreTurn(turn, result);
+        applied = true;
+      }
+    }
+    this.current = void 0;
+    this.pendingRedo = applied ? redo : void 0;
+    return applied ? result : void 0;
+  }
+  /**
+   * Re-apply the file state captured right before the last undo/undoTo.
+   * Only file edits are redone, never conversation history. Invalidated by
+   * any new snapshot turn or clear(), so redo can't resurrect stale content.
+   */
+  async redo() {
+    const turn = this.pendingRedo;
+    if (!turn) return void 0;
+    this.pendingRedo = void 0;
+    const result = emptyResult();
+    await restoreTurn(turn, result);
+    return result;
+  }
+  /** Records the on-disk state of a turn's paths so redo() can put it back. */
+  async captureFor(turn, into) {
+    for (const [path, original] of turn) {
+      if (into.has(path)) continue;
+      if (original === "skipped") {
+        into.set(path, "skipped");
+        continue;
+      }
+      try {
+        if (!existsSync2(path)) into.set(path, null);
+        else if (statSync(path).size > MAX_BYTES) into.set(path, "skipped");
+        else into.set(path, await readFile5(path));
+      } catch {
+        into.set(path, "skipped");
+      }
+    }
+  }
+  clear() {
+    this.history.length = 0;
+    this.current = void 0;
+    this.pendingRedo = 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 z7 } 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 clean = (s) => s.replace(/[^A-Za-z0-9_-]+/g, "_");
+  const base = `mcp__${clean(server)}__${clean(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: z7.record(z7.string(), z7.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 z8 } 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: z8.object({ plan: z8.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 z9 } 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: z9.object({ name: z9.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/task.ts
+import { z as z10 } 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: z10.object({
+      agent: z10.string().describe("Agent name"),
+      description: z10.string().describe("3-6 word summary shown to the user"),
+      prompt: z10.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 Agent({
+        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 z11 } 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: z11.object({
+      todos: z11.array(z11.object({ content: z11.string(), status: z11.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 z12 } 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: z12.object({
+      content: z12.string().min(1).max(500).describe("One short line, without a leading bullet (it is added for you)"),
+      scope: z12.enum(["project", "global"]).optional().describe("project (default) or global")
+    }),
+    kind: "edit",
+    // The target is what the prompt shows and what the permission model judges: the
+    // global store really lives outside the project, so it must not look like one.
+    target: (input) => input.scope === "global" ? join(opts.home, "BCCLI.md") : "AGENTS.md",
+    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/tools/repomap.ts
+import { z as z13 } from "zod";
+
+// src/repomap.ts
+import { readdirSync, readFileSync as readFileSync3 } from "fs";
+import { extname, join as join2, relative, sep } from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  "target",
+  "vendor",
+  "__pycache__",
+  ".venv",
+  ".cache"
+]);
+var CODE_EXTS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".c",
+  ".h",
+  ".cpp",
+  ".hpp",
+  ".cs",
+  ".rb",
+  ".php",
+  ".sh",
+  ".ps1"
+]);
+var MAX_FILES = 400;
+var MAX_FILE_BYTES = 2e5;
+var MAX_SYMBOLS_PER_FILE = 12;
+var FAMILY = {
+  ts: [
+    /^\s*(?:export\s+)?(?:default\s+)?(?:declare\s+)?(?:abstract\s+)?(?:async\s+)?(?:function|class|interface|type|enum)\s+([A-Za-z0-9_$]+)/,
+    /^\s*export\s+(?:const|let)\s+([A-Za-z0-9_$]+)/
+  ],
+  py: [/^\s*(?:async\s+)?def\s+(\w+)/, /^\s*class\s+(\w+)/],
+  go: [/^func\s+(?:\([^)]*\)\s*)?(\w+)/, /^type\s+(\w+)/],
+  rs: [/^\s*(?:pub(?:\([^)]*\))?\s+)?(?:unsafe\s+)?(?:async\s+)?(?:fn|struct|enum|trait|type)\s+(\w+)/],
+  c: [/^\s*(?:static\s+|inline\s+|extern\s+)*[A-Za-z_][A-Za-z0-9_\s*]*\b(\w+)\s*\([^;]*\)\s*\{?\s*$/]
+};
+function familyFor(ext) {
+  if ([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".java", ".cs", ".php", ".rb"].includes(ext)) return FAMILY.ts;
+  if (ext === ".py" || ext === ".sh" || ext === ".ps1") return FAMILY.py;
+  if (ext === ".go") return FAMILY.go;
+  if (ext === ".rs") return FAMILY.rs;
+  return FAMILY.c;
+}
+function extractSymbols(text, ext) {
+  const out = [];
+  for (const line of text.split("\n")) {
+    for (const re of familyFor(ext)) {
+      const m = re.exec(line);
+      if (m) {
+        if (!out.includes(m[1])) out.push(m[1]);
+        break;
+      }
+    }
+    if (out.length >= MAX_SYMBOLS_PER_FILE) break;
+  }
+  return out;
+}
+function walk(dir, root, files) {
+  if (files.length >= MAX_FILES) return;
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    if (files.length >= MAX_FILES) return;
+    const full = join2(dir, e.name);
+    if (e.isDirectory()) {
+      if (SKIP_DIRS.has(e.name) || e.name.startsWith(".") && full !== root) continue;
+      walk(full, root, files);
+    } else if (e.isFile() && CODE_EXTS.has(extname(e.name).toLowerCase())) {
+      files.push(full);
+    }
+  }
+}
+function buildRepoMapSync(cwd, opts = {}) {
+  const maxTokens = opts.maxTokens ?? 2048;
+  const files = [];
+  walk(cwd, cwd, files);
+  files.sort(
+    (a, b) => relative(cwd, a).split(sep).length - relative(cwd, b).split(sep).length || a.localeCompare(b)
+  );
+  const lines = [];
+  let used = 0;
+  let truncated = false;
+  for (const file of files) {
+    const rel = relative(cwd, file).split(sep).join("/");
+    let symbols = [];
+    try {
+      const text = readFileSync3(file, "utf8");
+      if (text.length <= MAX_FILE_BYTES) symbols = extractSymbols(text, extname(file).toLowerCase());
+    } catch {
+      symbols = [];
+    }
+    const line = symbols.length ? `${rel}: ${symbols.join(", ")}` : rel;
+    const cost = estimateTokens(line);
+    if (used + cost > maxTokens) {
+      truncated = true;
+      break;
+    }
+    used += cost;
+    lines.push(line);
+  }
+  if (truncated) lines.push(`\u2026 truncated (repo map limited to ${maxTokens} tokens)`);
+  return lines.join("\n");
+}
+
+// src/tools/repomap.ts
+function createRepoMapTool() {
+  return defineTool({
+    name: "repo_map",
+    description: "Show a map of this repository: code files (node_modules/.git excluded) with their top-level functions, classes and types. Use it to orient yourself in an unfamiliar repo before searching or reading files.",
+    schema: z13.object({}),
+    kind: "read",
+    target: () => "(repo)",
+    programmaticSafe: true,
+    run: async (_input, ctx) => ({ output: buildRepoMapSync(ctx.cwd) || "(no code files found)" })
+  });
+}
+
+// src/tools/diagnostics.ts
+import { extname as extname2 } from "path";
+import { z as z14 } from "zod";
+
+// src/lsp.ts
+import { spawn } from "child_process";
+import { readFileSync as readFileSync4 } from "fs";
+import { pathToFileURL } from "url";
+function encodeLsp(msg) {
+  const body = Buffer.from(JSON.stringify(msg), "utf8");
+  return Buffer.concat([Buffer.from(`Content-Length: ${body.length}\r
+\r
+`, "ascii"), body]);
+}
+function createLspParser(onMessage) {
+  let buf = Buffer.alloc(0);
+  return {
+    push(chunk) {
+      buf = Buffer.concat([buf, chunk]);
+      for (; ; ) {
+        const idx = buf.indexOf("\r\n\r\n");
+        if (idx < 0) return;
+        const m = /Content-Length:\s*(\d+)/i.exec(buf.subarray(0, idx).toString("ascii"));
+        if (!m) {
+          buf = buf.subarray(idx + 4);
+          continue;
+        }
+        const len = Number(m[1]);
+        if (buf.length < idx + 4 + len) return;
+        const body = buf.subarray(idx + 4, idx + 4 + len);
+        buf = buf.subarray(idx + 4 + len);
+        try {
+          onMessage(JSON.parse(body.toString("utf8")));
+        } catch {
+        }
+      }
+    }
+  };
+}
+function getDiagnostics(opts) {
+  return new Promise((resolve2) => {
+    const child = spawn(opts.server.command, opts.server.args ?? [], { cwd: opts.cwd, stdio: ["pipe", "pipe", "ignore"] });
+    const uri = pathToFileURL(opts.file).href;
+    let settled = false;
+    let nextId = 2;
+    const send = (msg) => {
+      try {
+        child.stdin.write(encodeLsp(msg));
+      } catch {
+      }
+    };
+    const finish = (diags) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      send({ jsonrpc: "2.0", id: nextId++, method: "shutdown" });
+      send({ jsonrpc: "2.0", method: "exit" });
+      const killer = setTimeout(() => {
+        try {
+          child.kill();
+        } catch {
+        }
+      }, 500);
+      killer.unref?.();
+      resolve2(diags);
+    };
+    const timer = setTimeout(() => finish([]), opts.timeoutMs ?? 8e3);
+    const parser = createLspParser((msg) => {
+      if (msg.id === 1 && msg.result) {
+        send({ jsonrpc: "2.0", method: "initialized", params: {} });
+        let text = "";
+        try {
+          text = readFileSync4(opts.file, "utf8");
+        } catch {
+        }
+        send({
+          jsonrpc: "2.0",
+          method: "textDocument/didOpen",
+          params: { textDocument: { uri, languageId: "plaintext", version: 1, text } }
+        });
+      }
+      if (msg.method === "textDocument/publishDiagnostics" && msg.params?.uri === uri) {
+        finish(
+          (msg.params.diagnostics ?? []).map((d) => ({
+            line: d.range?.start?.line ?? 0,
+            character: d.range?.start?.character ?? 0,
+            severity: d.severity ?? 1,
+            message: String(d.message ?? "")
+          }))
+        );
+      }
+    });
+    child.stdout?.on("data", (c) => parser.push(c));
+    child.on("error", () => finish([]));
+    child.on("close", () => finish([]));
+    send({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "initialize",
+      params: { processId: process.pid, capabilities: {}, rootUri: pathToFileURL(opts.cwd).href }
+    });
+  });
+}
+
+// src/tools/diagnostics.ts
+var SEVERITY = { 1: "error", 2: "warning", 3: "info", 4: "hint" };
+var SCHEMA = z14.object({ path: z14.string().describe("File to check (absolute or relative to the working directory)") });
+function createDiagnosticsTool(servers) {
+  return defineTool({
+    name: "diagnostics",
+    description: 'Run the configured LSP server(s) on one file and return its diagnostics (errors/warnings). Configure servers under "lsp.servers" in ~/.bccli/config.json, e.g. { "extensions": [".ts"], "command": "typescript-language-server", "args": ["--stdio"] }.',
+    schema: SCHEMA,
+    kind: "read",
+    target: (input) => input.path,
+    async run(input, ctx) {
+      const file = resolvePath(ctx.cwd, input.path);
+      const ext = extname2(file).toLowerCase();
+      const server = servers.find((s) => s.extensions.includes(ext));
+      if (!server) {
+        return { output: t("No LSP server is configured for {ext} files.", { ext: ext || "(none)" }), isError: true };
+      }
+      const diags = await getDiagnostics({ server, cwd: ctx.cwd, file, timeoutMs: 15e3 });
+      if (!diags.length) return { output: "No diagnostics." };
+      const lines = diags.map((d) => `${input.path}:${d.line + 1}:${d.character + 1} ${SEVERITY[d.severity] ?? "error"} ${d.message}`);
+      return { output: lines.join("\n"), isError: diags.some((d) => d.severity === 1) };
+    }
+  });
+}
+
+// src/plugins.ts
+import { existsSync as existsSync4 } from "fs";
+import { createRequire } from "module";
+import { isAbsolute as isAbsolute2, join as join3 } 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(".") ? join3(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 asRecord = mod ?? {};
+    const activate = typeof mod === "function" ? mod : typeof asRecord.default === "function" ? asRecord.default : typeof asRecord.activate === "function" ? asRecord.activate : void 0;
+    if (!activate) {
+      throw new ConfigError(
+        t("Plugin failed to load: {spec}: {reason}", {
+          spec,
+          reason: "no activate function (use export default fn, export function activate, or module.exports = fn)"
+        })
+      );
+    }
+    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,
+      fetch: opts.fetch,
+      // diteruskan penuh (spec gh-bot §6.6 — juga memperbaiki sdk fetch-injection)
+      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 repoMap = config.repoMap ? buildRepoMapSync(opts.cwd) : void 0;
+  const systemFor = (model) => buildSystemPrompt({ cwd: opts.cwd, home, model, skills, repoMap });
+  const systemPrompt = systemFor(modelRef);
+  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(systemFor(modelRef));
+  const saveMemory = createSaveMemoryTool({ home, onSaved: rebuildPrompt });
+  const baseTools = [
+    createReadTool({ vision: config.vision }),
+    createBashTool({ networkPolicy: config.networkPolicy, sandbox: config.sandbox === "on" }),
+    ...ALL_TOOLS.filter((tool) => tool.name !== "read" && tool.name !== "bash"),
+    webSearch,
+    createSkillTool(skills),
+    createTodoTool(todos),
+    createExitPlanTool({ permissions, interaction }),
+    saveMemory,
+    createRepoMapTool()
+  ];
+  if (config.lsp?.servers.length) baseTools.push(createDiagnosticsTool(config.lsp.servers));
+  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) => systemFor(childModelRef ?? modelRef),
+    cwd: opts.cwd,
+    reasoning: () => reasoning,
+    hooks: config.hooks,
+    pluginEmit,
+    env
+  });
+  const agent = new Agent({
+    provider,
+    tools: [...baseTools, task],
+    permissions,
+    systemPrompt,
+    cwd: opts.cwd,
+    history,
+    reasoning,
+    maxSteps: opts.maxSteps ?? config.maxSteps,
+    hooks: config.hooks,
+    pluginEmit,
+    env,
+    usageCap: config.usageCap,
+    budgetModel: modelRef,
+    contextWindow: contextWindowFor(modelRef, env),
+    onMessage: (m) => session.append(m),
+    onUsage: (u) => session.appendUsage({ ...u, model: modelRef }),
+    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(systemFor(modelRef));
+    },
+    setReasoning(level) {
+      reasoning = level;
+      agent.reasoning = level;
+    }
+  };
+}
+
+export {
+  lunaPtcAutoEnabled,
+  createRuntime
+};