@botconnector/bccli 0.4.16 → 0.5.0-rc.4

package/dist/chunk-ZJRZTMJF.js

@@ -1,2669 +0,0 @@
-#!/usr/bin/env node
-import {
-  estimateMessages,
-  estimateTokens,
-  pruneOldToolOutputs,
-  splitKeepRecent,
-  trimToFit
-} from "./chunk-OK2USAXX.js";
-import {
-  BUILTIN_AGENTS,
-  appendMemory,
-  bashTool,
-  buildSystemPrompt,
-  createBashTool,
-  errorCode,
-  ignorePatterns,
-  isFileModifiedSinceRead,
-  loadAgentDefs,
-  loadCommands,
-  loadSkills,
-  normalizeGlobPath,
-  parseFrontmatter,
-  recordFileMtime,
-  resolvePath,
-  runHooks,
-  validateGlobPattern
-} from "./chunk-KDVL2NP6.js";
-import {
-  createWebSearchTool,
-  fetchTool
-} from "./chunk-7GM6NN5E.js";
-import {
-  defineTool
-} from "./chunk-PSO7R5AD.js";
-import {
-  Permissions
-} from "./chunk-YYTFJUO2.js";
-import {
-  addProviderKey
-} from "./chunk-SWNRA3EW.js";
-import {
-  listAllModels
-} from "./chunk-INMSTUB2.js";
-import {
-  providerName
-} from "./chunk-6SDRWEPN.js";
-import {
-  FileOAuthProvider,
-  hasStoredTokens
-} from "./chunk-3CYQYHPK.js";
-import {
-  Session
-} from "./chunk-KEKDRROL.js";
-import {
-  completionAssistantMessage,
-  createProvider,
-  hasPendingProgrammaticReplay,
-  imageUserMessage,
-  withFallbackProvider
-} from "./chunk-6JK4IBGK.js";
-import {
-  expandEnvVars
-} from "./chunk-Q42ZGVAQ.js";
-import {
-  ConfigError,
-  bccliHome,
-  loadConfig,
-  resolveModel
-} from "./chunk-TLCL6DC7.js";
-import {
-  t
-} from "./chunk-R754XIBJ.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/edit.ts
-var editEntrySchema = z.object({
-  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")
-});
-var schema = z.object({
-  path: z.string().describe("File path, relative to the project or absolute"),
-  old_string: z.string().optional().describe("Exact text to replace; must be unique unless replace_all"),
-  new_string: z.string().optional().describe("Replacement text"),
-  replace_all: z.boolean().optional().describe("Replace every occurrence"),
-  edits: z.array(editEntrySchema).optional().describe("Optional list of sequential edits to apply atomically to the same file")
-});
-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 normalizeTypographic(s) {
-  return s.replace(/[\u2018\u2019\u201A\u201B]/g, "'").replace(/[\u201C\u201D\u201E\u201F]/g, '"').replace(/[\u2013\u2014]/g, "-").replace(/\u00A0/g, " ");
-}
-function stripReadLinePrefixes(s) {
-  const lines = s.split(/\r?\n/);
-  if (lines.every((l) => !l.trim() || /^\s*\d+\t/.test(l))) {
-    return lines.map((l) => l.replace(/^\s*\d+\t/, "")).join("\n");
-  }
-  return s;
-}
-function matchByNormalizedLines(content, oldText, newText, replaceAll) {
-  const eol = content.includes("\r\n") ? "\r\n" : "\n";
-  const fileLines = content.split(/\r?\n/);
-  const oldLines = stripReadLinePrefixes(oldText).split(/\r?\n/);
-  if (!oldLines.length) return { count: 0 };
-  const normLine = (l) => normalizeTypographic(l).trimEnd();
-  const normOld = oldLines.map(normLine);
-  const matches = [];
-  for (let i = 0; i + oldLines.length <= fileLines.length; i++) {
-    let ok = true;
-    for (let j = 0; j < oldLines.length; j++) {
-      if (normLine(fileLines[i + j]) !== normOld[j]) {
-        ok = false;
-        break;
-      }
-    }
-    if (ok) {
-      matches.push(i);
-      if (replaceAll) i += oldLines.length - 1;
-    }
-  }
-  if (matches.length === 0) return { count: 0 };
-  if (matches.length > 1 && !replaceAll) return { count: matches.length };
-  const replacementLines = stripReadLinePrefixes(newText).split(/\r?\n/);
-  const outLines = [...fileLines];
-  for (let m = matches.length - 1; m >= 0; m--) {
-    outLines.splice(matches[m], oldLines.length, ...replacementLines);
-  }
-  return { count: matches.length, result: outLines.join(eol) };
-}
-function applySingleEdit(content, path, 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 strippedOld = stripReadLinePrefixes(input.old_string);
-  const strippedNew = stripReadLinePrefixes(input.new_string);
-  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)]);
-  if (strippedOld !== input.old_string) {
-    attempts.push([strippedOld, strippedNew], [toEol(strippedOld), toEol(strippedNew)]);
-  }
-  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 ${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);
-  }
-  const fuzzy = matchByNormalizedLines(content, input.old_string, input.new_string, input.replace_all);
-  if (fuzzy.count > 1 && !input.replace_all) {
-    return {
-      output: `old_string appears ${fuzzy.count} times in ${path}. Add more context to make it unique, or use replace_all.`,
-      isError: true
-    };
-  }
-  if (fuzzy.count > 0 && fuzzy.result !== void 0) return fuzzy.result;
-  return { output: `old_string not found in ${path}. Re-read the file.`, isError: true };
-}
-function applyEdit(content, input) {
-  const list = input.edits?.length ? input.edits : input.old_string !== void 0 && input.new_string !== void 0 ? [{ old_string: input.old_string, new_string: input.new_string, replace_all: input.replace_all }] : [];
-  if (!list.length) return { output: "Provide old_string and new_string (or edits array).", isError: true };
-  let current = content;
-  for (const item of list) {
-    const next = applySingleEdit(current, input.path, item);
-    if (typeof next !== "string") return next;
-    current = next;
-  }
-  return current;
-}
-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.`;
-    if (isFileModifiedSinceRead(ctx.readFiles, abs)) {
-      return `${input.path} has been modified since it was last read. Read it again before editing.`;
-    }
-    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 };
-    }
-    if (isFileModifiedSinceRead(ctx.readFiles, abs)) {
-      return { output: `${input.path} has been modified since it was last read. Read it again before editing.`, 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);
-    recordFileMtime(ctx.readFiles, abs);
-    return { output: `Edited ${input.path}.`, display: formatDiff(diffLines(content, next)) };
-  }
-});
-
-// src/tools/glob.ts
-import { statSync } from "fs";
-import { glob as nativeGlob } from "fs/promises";
-import { join } from "path";
-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((resolve, reject) => {
-    const onAbort = () => resolve(ABORTED);
-    signal.addEventListener("abort", onAbort, { once: true });
-    promise.then(
-      (value) => {
-        signal.removeEventListener("abort", onAbort);
-        resolve(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.path ? `${input.pattern} ${input.path}` : 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.cwd) }),
-      ctx.signal,
-      (file) => files.push(normalizeGlobPath(file))
-    );
-    if (!finished) return { output: "Cancelled by the user.", isError: true };
-    const mtime = (rel) => {
-      try {
-        return statSync(join(root, rel)).mtimeMs;
-      } catch {
-        return 0;
-      }
-    };
-    const mtimes = new Map(files.map((f) => [f, mtime(f)]));
-    files.sort((a, b) => {
-      const diff = (mtimes.get(b) ?? 0) - (mtimes.get(a) ?? 0);
-      return Math.abs(diff) >= 50 ? diff : a.localeCompare(b);
-    });
-    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 { statSync as statSync2 } from "fs";
-import { readFile as readFile2 } from "fs/promises";
-import { glob as nativeGlob2 } from "fs/promises";
-import { basename, dirname } from "path";
-import { z as z3 } from "zod";
-var MAX_MATCHES = 200;
-var MAX_OUTPUT_CHARS2 = 24e3;
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function isSingleFile(p) {
-  try {
-    return statSync2(p).isFile();
-  } catch {
-    return false;
-  }
-}
-async function grepJs(pattern, opts) {
-  const source = opts.literal ? escapeRegExp(pattern) : pattern;
-  const regex = new RegExp(source, opts.ignoreCase ? "i" : "");
-  const single = isSingleFile(opts.root);
-  const files = [];
-  if (single) {
-    files.push(basename(opts.root));
-  } else {
-    const finished = await collectUntilAbort(
-      nativeGlob2(opts.glob ?? "**/*", { cwd: opts.root, exclude: ignorePatterns(opts.root, opts.projectRoot) }),
-      opts.signal,
-      (file) => files.push(normalizeGlobPath(file))
-    );
-    if (!finished) return [];
-  }
-  const baseDir = single ? dirname(opts.root) : opts.root;
-  const ctxLines = Math.max(0, Math.min(10, Math.floor(opts.context ?? 0)));
-  const mode = opts.outputMode ?? "content";
-  const out = [];
-  for (const file of files.sort()) {
-    if (opts.signal?.aborted) break;
-    let text;
-    try {
-      const buffer = await readFile2(resolvePath(baseDir, file));
-      if (buffer.subarray(0, 8e3).includes(0)) continue;
-      text = buffer.toString("utf8");
-    } catch {
-      continue;
-    }
-    const lines = text.split(/\r?\n/);
-    let fileMatches = 0;
-    for (let i = 0; i < lines.length && out.length < MAX_MATCHES; i++) {
-      if (regex.test(lines[i])) {
-        fileMatches++;
-        if (mode === "files_with_matches") {
-          out.push(file);
-          break;
-        }
-        if (mode === "content") {
-          const from = Math.max(0, i - ctxLines);
-          const to = Math.min(lines.length - 1, i + ctxLines);
-          for (let j = from; j <= to && out.length < MAX_MATCHES; j++) {
-            const sep2 = j === i ? ":" : "-";
-            out.push(`${file}${sep2}${j + 1}${sep2}${lines[j].slice(0, 300)}`);
-          }
-        }
-      }
-    }
-    if (mode === "count" && fileMatches > 0) out.push(`${file}:${fileMatches}`);
-    if (out.length >= MAX_MATCHES) break;
-  }
-  return out;
-}
-function grepRg(pattern, opts) {
-  const single = isSingleFile(opts.root);
-  const cwd = single ? dirname(opts.root) : opts.root;
-  const target = single ? basename(opts.root) : ".";
-  const mode = opts.outputMode ?? "content";
-  const args = ["--color", "never"];
-  if (mode === "files_with_matches") {
-    args.push("--files-with-matches");
-  } else if (mode === "count") {
-    args.push("--count");
-  } else {
-    args.push("--line-number", "--no-heading", "--max-columns", "300");
-    if (opts.context && opts.context > 0) args.push("-C", String(Math.min(10, Math.floor(opts.context))));
-  }
-  if (opts.literal) args.push("-F");
-  if (opts.ignoreCase) args.push("-i");
-  if (opts.glob && !single) args.push("-g", opts.glob);
-  args.push("-e", pattern, target);
-  return new Promise((resolve) => {
-    execFile("rg", args, { cwd, maxBuffer: 10 * 1024 * 1024, signal: opts.signal }, (error, stdout) => {
-      if (opts.signal?.aborted) return resolve([]);
-      const code = error?.code;
-      if (code === "ENOENT") return resolve(void 0);
-      if (error && error.code !== 1) return resolve(void 0);
-      resolve(
-        stdout.split(/\r?\n/).filter(Boolean).map((l) => l.replace(/^\.[\\/]/, "").replace(/\\/g, "/")).slice(0, MAX_MATCHES)
-      );
-    });
-  });
-}
-var grepTool = defineTool({
-  name: "grep",
-  description: "Search file contents with a regular expression or literal text. Respects .gitignore. Returns path:line:text (max 200).",
-  schema: z3.object({
-    pattern: z3.string().describe("Regular expression or literal string"),
-    path: z3.string().optional().describe("File or directory to search, default project root"),
-    glob: z3.string().optional().describe('Only files matching this glob, e.g. "**/*.ts"'),
-    ignore_case: z3.boolean().optional(),
-    literal: z3.boolean().optional().describe("Treat pattern as literal text instead of regex"),
-    context: z3.number().int().min(0).max(10).optional().describe("Number of context lines before and after each match"),
-    output_mode: z3.enum(["content", "files_with_matches", "count"]).optional().describe("Output format, default content")
-  }),
-  kind: "read",
-  target: (input) => input.path ? `${input.pattern} ${input.path}` : 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 ?? "."),
-      projectRoot: ctx.cwd,
-      glob: input.glob,
-      ignoreCase: input.ignore_case,
-      literal: input.literal,
-      context: input.context,
-      outputMode: input.output_mode,
-      signal: ctx.signal
-    };
-    if (!input.literal) {
-      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 { readdirSync, statSync as statSync3 } from "fs";
-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;
-  if (start >= lines.length) {
-    return {
-      output: `offset ${input.offset} is past the end of ${input.path} (${lines.length} line(s)); start at 1.`,
-      isError: true
-    };
-  }
-  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);
-      try {
-        if (statSync3(abs).isDirectory()) {
-          const entries = readdirSync(abs, { withFileTypes: true }).map((e) => e.isDirectory() ? `${e.name}/` : e.name).sort((a, b) => a.localeCompare(b));
-          const start = (input.offset ?? 1) - 1;
-          const limit = input.limit ?? 2e3;
-          const slice = entries.slice(start, start + limit);
-          return { output: slice.join("\n") || "(empty directory)", display: t("{n} lines", { n: slice.length }) };
-        }
-      } catch {
-      }
-      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) {
-        recordFileMtime(ctx.readFiles, 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 };
-      }
-      recordFileMtime(ctx.readFiles, 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 as dirname2 } 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);
-    if (existsSync(abs) && !ctx.readFiles.has(abs)) return `${input.path} already exists. Read it with read before overwriting it.`;
-    if (isFileModifiedSinceRead(ctx.readFiles, abs)) return `${input.path} has been modified since it was last read. Read it again before overwriting it.`;
-    return 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 };
-    }
-    if (isFileModifiedSinceRead(ctx.readFiles, abs)) {
-      return { output: `${input.path} has been modified since it was last read. Read it again before overwriting it.`, isError: true };
-    }
-    try {
-      await ctx.checkpoint?.(abs);
-      await mkdir(dirname2(abs), { recursive: true });
-      await writeFile2(abs, input.content);
-    } catch (error) {
-      return { output: `Failed to write ${input.path}: ${errorCode(error)}`, isError: true };
-    }
-    recordFileMtime(ctx.readFiles, 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 cached = Math.max(0, Math.min(usage.cachedInputTokens ?? 0, usage.inputTokens));
-      const cachedRate = price.cachedInput ?? price.input;
-      const usd = ((usage.inputTokens - cached) * price.input + cached * cachedRate + 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.budgetModel = opts.budgetModel ?? "";
-    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;
-  budgetModel;
-  systemPrompt;
-  setSystemPrompt(text) {
-    this.systemPrompt = text;
-  }
-  setContextWindow(window) {
-    this.contextWindow = window;
-  }
-  getContextWindow() {
-    return this.contextWindow;
-  }
-  setBudgetModel(model) {
-    this.budgetModel = model;
-  }
-  getBudgetModel() {
-    return this.budgetModel;
-  }
-  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.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 as statSync4 } 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;
-  offset = 0;
-  beginTurn() {
-    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 (statSync4(path).size > MAX_BYTES) turn.set(path, "skipped");
-    else turn.set(path, await readFile5(path));
-    while (this.turns() > MAX_TURNS) {
-      this.history.shift();
-      this.offset++;
-    }
-  }
-  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.offset + 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.offset, 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 undoEntry = /* @__PURE__ */ new Map();
-    await this.captureFor(turn, undoEntry);
-    const result = emptyResult();
-    await restoreTurn(turn, result);
-    if (undoEntry.size) this.history.push(undoEntry);
-    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 (statSync4(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;
-    this.offset = 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";
-function formatMcpContent(content) {
-  const parts = [];
-  const images = [];
-  for (const c of content ?? []) {
-    if (c.type === "text") {
-      parts.push(c.text ?? "");
-    } else if (c.type === "image" && c.data) {
-      const mediaType = c.mimeType || "image/png";
-      images.push({ mediaType, data: c.data, path: "mcp:image" });
-      parts.push(`[image attached: ${mediaType}]`);
-    } else if (c.type === "resource" && c.resource?.text) {
-      parts.push(c.resource.uri ? `[${c.resource.uri}]
-${c.resource.text}` : c.resource.text);
-    } else {
-      parts.push(`[${c.type}]`);
-    }
-  }
-  return {
-    output: parts.join("\n") || "(empty)",
-    ...images.length ? { images } : {}
-  };
-}
-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 formatted = formatMcpContent(result.content);
-          const output = formatted.output;
-          return {
-            output: output.length > 32e3 ? `${output.slice(0, 32e3)}
-\u2026 [truncated at 32000 characters; narrow the MCP request if possible]` : output,
-            isError: !!result.isError,
-            ...formatted.images ? { images: formatted.images } : {}
-          };
-        } 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");
-  const sessions = /* @__PURE__ */ new Map();
-  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"),
-      session_id: z10.string().optional().describe("Optional session id to continue a previous subagent conversation")
-    }),
-    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 priorHistory = input.session_id ? sessions.get(input.session_id) : void 0;
-      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,
-        ...priorHistory ? { history: priorHistory } : {},
-        // 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);
-      if (input.session_id) sessions.set(input.session_id, [...child.messages]);
-      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 };
-      let last = [...child.messages].reverse().find((m) => m.role === "assistant" && m.content);
-      if (!last && outcome?.type === "stepLimit" && !ctx.signal.aborted) {
-        try {
-          const synthesis = await provider.chat({
-            messages: [
-              ...child.messages,
-              { role: "user", content: "Step limit reached. Summarize all findings gathered so far concisely." }
-            ],
-            signal: ctx.signal,
-            reasoning: opts.reasoning?.() ?? "auto"
-          });
-          if (synthesis.text.trim()) {
-            last = { role: "assistant", content: synthesis.text.trim() };
-          }
-        } catch {
-        }
-      }
-      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 as join2 } 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" ? join2(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" ? join2(opts.home, "BCCLI.md") : join2(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 as readdirSync2, readFileSync as readFileSync3 } from "fs";
-import { extname, join as join3, relative, sep } from "path";
-var SKIP_DIRS = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  "dist",
-  "build",
-  "out",
-  "coverage",
-  ".next",
-  ".turbo",
-  "target",
-  "vendor",
-  "__pycache__",
-  "venv",
-  ".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_SCAN_FILES = 5e3;
-var MAX_FILE_BYTES = 2e5;
-var MAX_SYMBOLS_PER_FILE = 12;
-var FAMILY = {
-  ts: [
-    /^\s*(?:export\s+)?(?:default\s+)?(?:declare\s+)?(?:public\s+|private\s+|protected\s+|internal\s+)?(?:static\s+)?(?:abstract\s+|final\s+|sealed\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*(?:module|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"].includes(ext)) return FAMILY.ts;
-  if (ext === ".py" || ext === ".rb" || 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_SCAN_FILES) return;
-  let entries;
-  try {
-    entries = readdirSync2(dir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-    if (files.length >= MAX_SCAN_FILES) return;
-    const full = join3(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 scanned = [];
-  walk(cwd, cwd, scanned);
-  scanned.sort(
-    (a, b) => relative(cwd, a).split(sep).length - relative(cwd, b).split(sep).length || a.localeCompare(b)
-  );
-  const files = scanned.slice(0, MAX_FILES);
-  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 extname3, relative as relative2 } from "path";
-import { z as z14 } from "zod";
-
-// src/lsp.ts
-import { spawn } from "child_process";
-import { readFileSync as readFileSync4 } from "fs";
-import { extname as extname2 } from "path";
-import { fileURLToPath, pathToFileURL } from "url";
-var LANGUAGE_IDS = {
-  ".ts": "typescript",
-  ".tsx": "typescriptreact",
-  ".mts": "typescript",
-  ".cts": "typescript",
-  ".js": "javascript",
-  ".jsx": "javascriptreact",
-  ".mjs": "javascript",
-  ".cjs": "javascript",
-  ".py": "python",
-  ".rs": "rust",
-  ".go": "go",
-  ".java": "java",
-  ".c": "c",
-  ".h": "c",
-  ".cpp": "cpp",
-  ".hpp": "cpp",
-  ".cs": "csharp",
-  ".rb": "ruby",
-  ".php": "php",
-  ".json": "json",
-  ".md": "markdown",
-  ".sh": "shellscript",
-  ".ps1": "powershell",
-  ".yaml": "yaml",
-  ".yml": "yaml",
-  ".toml": "toml",
-  ".html": "html",
-  ".css": "css"
-};
-function languageIdFor(file) {
-  return LANGUAGE_IDS[extname2(file).toLowerCase()] ?? "plaintext";
-}
-function useShellForLsp(command, platform = process.platform) {
-  return platform === "win32" && !/\.(exe|mjs|cjs|js)$/i.test(command.trim());
-}
-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 extractHoverText(contents) {
-  if (!contents) return "";
-  if (typeof contents === "string") return contents.trim();
-  if (Array.isArray(contents)) return contents.map(extractHoverText).filter(Boolean).join("\n\n");
-  if (typeof contents === "object" && "value" in contents && typeof contents.value === "string") {
-    return contents.value.trim();
-  }
-  return "";
-}
-function normalizeLocations(raw) {
-  const items = Array.isArray(raw) ? raw : raw ? [raw] : [];
-  const out = [];
-  for (const item of items) {
-    if (!item || typeof item !== "object") continue;
-    const rec = item;
-    const uri = rec.uri ?? rec.targetUri;
-    const start = rec.range?.start ?? rec.targetSelectionRange?.start ?? rec.targetRange?.start;
-    if (!uri) continue;
-    let path = uri;
-    try {
-      if (uri.startsWith("file:")) path = fileURLToPath(uri);
-    } catch {
-    }
-    out.push({
-      uri,
-      path,
-      line: start?.line ?? 0,
-      character: start?.character ?? 0
-    });
-  }
-  return out;
-}
-function createWarmLspClient(opts) {
-  let child;
-  let initPromise;
-  let nextId = 2;
-  const opened = /* @__PURE__ */ new Map();
-  const pendingRpc = /* @__PURE__ */ new Map();
-  const diagWaiters = /* @__PURE__ */ new Map();
-  const send = (msg) => {
-    try {
-      child?.stdin?.write(encodeLsp(msg));
-    } catch {
-    }
-  };
-  const resetState = () => {
-    child = void 0;
-    initPromise = void 0;
-    opened.clear();
-    for (const [, resolve] of pendingRpc) resolve(void 0);
-    pendingRpc.clear();
-    for (const [, waiters] of diagWaiters) {
-      for (const w of waiters) w([]);
-    }
-    diagWaiters.clear();
-  };
-  const ensureStarted = () => {
-    if (initPromise && child && !child.killed) return initPromise;
-    opened.clear();
-    initPromise = new Promise((resolveInit) => {
-      const proc = spawn(opts.server.command, opts.server.args ?? [], {
-        cwd: opts.cwd,
-        stdio: ["pipe", "pipe", "ignore"],
-        shell: useShellForLsp(opts.server.command)
-      });
-      child = proc;
-      let initSettled = false;
-      const settleInit = () => {
-        if (!initSettled) {
-          initSettled = true;
-          resolveInit();
-        }
-      };
-      const parser = createLspParser((msg) => {
-        if (msg.id === 1 && msg.result !== void 0) {
-          send({ jsonrpc: "2.0", method: "initialized", params: {} });
-          settleInit();
-          return;
-        }
-        if (msg.id !== void 0 && pendingRpc.has(msg.id)) {
-          const fn = pendingRpc.get(msg.id);
-          pendingRpc.delete(msg.id);
-          fn?.(msg.result);
-          return;
-        }
-        if (msg.method === "textDocument/publishDiagnostics" && msg.params?.uri) {
-          const uri = msg.params.uri;
-          const diags = (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 ?? "")
-          }));
-          const list = diagWaiters.get(uri);
-          if (list?.length) {
-            diagWaiters.delete(uri);
-            for (const w of list) w(diags);
-          }
-        }
-      });
-      proc.stdout?.on("data", (c) => parser.push(c));
-      proc.on("error", () => {
-        resetState();
-        settleInit();
-      });
-      proc.on("close", () => {
-        resetState();
-        settleInit();
-      });
-      send({
-        jsonrpc: "2.0",
-        id: 1,
-        method: "initialize",
-        params: { processId: process.pid, capabilities: {}, rootUri: pathToFileURL(opts.cwd).href }
-      });
-    });
-    return initPromise;
-  };
-  const syncDocument = (file) => {
-    const uri = pathToFileURL(file).href;
-    let text = "";
-    try {
-      text = readFileSync4(file, "utf8");
-    } catch {
-    }
-    const prevVersion = opened.get(uri);
-    if (prevVersion === void 0) {
-      opened.set(uri, 1);
-      send({
-        jsonrpc: "2.0",
-        method: "textDocument/didOpen",
-        params: { textDocument: { uri, languageId: languageIdFor(file), version: 1, text } }
-      });
-    } else {
-      const version = prevVersion + 1;
-      opened.set(uri, version);
-      send({
-        jsonrpc: "2.0",
-        method: "textDocument/didChange",
-        params: {
-          textDocument: { uri, version },
-          contentChanges: [{ text }]
-        }
-      });
-    }
-    return uri;
-  };
-  const request = (method, params, timeoutMs = opts.timeoutMs ?? 8e3) => new Promise((resolve) => {
-    const id = nextId++;
-    const timer = setTimeout(() => {
-      pendingRpc.delete(id);
-      resolve(void 0);
-    }, timeoutMs);
-    pendingRpc.set(id, (res) => {
-      clearTimeout(timer);
-      resolve(res);
-    });
-    send({ jsonrpc: "2.0", id, method, params });
-  });
-  return {
-    async diagnostics(file, timeoutMs = opts.timeoutMs ?? 8e3) {
-      await ensureStarted();
-      if (!child) return [];
-      const uri = pathToFileURL(file).href;
-      return new Promise((resolve) => {
-        const timer = setTimeout(() => {
-          const list2 = diagWaiters.get(uri) ?? [];
-          diagWaiters.set(
-            uri,
-            list2.filter((w) => w !== onDiag)
-          );
-          resolve([]);
-        }, timeoutMs);
-        const onDiag = (diags) => {
-          clearTimeout(timer);
-          resolve(diags);
-        };
-        const list = diagWaiters.get(uri) ?? [];
-        list.push(onDiag);
-        diagWaiters.set(uri, list);
-        syncDocument(file);
-      });
-    },
-    async hover(file, line, character, timeoutMs) {
-      await ensureStarted();
-      if (!child) return "";
-      const uri = syncDocument(file);
-      const res = await request("textDocument/hover", { textDocument: { uri }, position: { line, character } }, timeoutMs);
-      return extractHoverText(res?.contents);
-    },
-    async definition(file, line, character, timeoutMs) {
-      await ensureStarted();
-      if (!child) return [];
-      const uri = syncDocument(file);
-      const res = await request("textDocument/definition", { textDocument: { uri }, position: { line, character } }, timeoutMs);
-      return normalizeLocations(res);
-    },
-    async references(file, line, character, timeoutMs) {
-      await ensureStarted();
-      if (!child) return [];
-      const uri = syncDocument(file);
-      const res = await request(
-        "textDocument/references",
-        { textDocument: { uri }, position: { line, character }, context: { includeDeclaration: true } },
-        timeoutMs
-      );
-      return normalizeLocations(res);
-    },
-    async close() {
-      if (!child) return;
-      const proc = child;
-      send({ jsonrpc: "2.0", id: nextId++, method: "shutdown" });
-      send({ jsonrpc: "2.0", method: "exit" });
-      resetState();
-      const killer = setTimeout(() => {
-        try {
-          proc.kill();
-        } catch {
-        }
-      }, 200);
-      killer.unref?.();
-    }
-  };
-}
-
-// 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)"),
-  action: z14.enum(["diagnostics", "hover", "definition", "references"]).optional().describe("LSP query action, default diagnostics"),
-  line: z14.number().int().min(1).optional().describe("1-based line number for hover, definition, or references"),
-  character: z14.number().int().min(1).optional().describe("1-based column number for hover, definition, or references")
-});
-function createDiagnosticsTool(servers) {
-  const warmPool = /* @__PURE__ */ new Map();
-  const clientFor = (server, cwd) => {
-    const key = `${cwd}::${server.command}::${(server.args ?? []).join("\0")}`;
-    let client = warmPool.get(key);
-    if (!client) {
-      client = createWarmLspClient({ server, cwd, timeoutMs: 15e3 });
-      warmPool.set(key, client);
-    }
-    return client;
-  };
-  return defineTool({
-    name: "diagnostics",
-    description: 'Query the configured LSP server(s) on a file for diagnostics (errors/warnings), hover docs, definition, or references. 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 = extname3(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 client = clientFor(server, ctx.cwd);
-      const action = input.action ?? "diagnostics";
-      const line0 = Math.max(0, (input.line ?? 1) - 1);
-      const char0 = Math.max(0, (input.character ?? 1) - 1);
-      if (action === "hover") {
-        const text = await client.hover(file, line0, char0, 15e3);
-        return { output: text || "No hover information." };
-      }
-      if (action === "definition" || action === "references") {
-        const locs = action === "definition" ? await client.definition(file, line0, char0, 15e3) : await client.references(file, line0, char0, 15e3);
-        if (!locs.length) return { output: `No ${action} found.` };
-        const formatted = locs.map((l) => {
-          const rel = relative2(ctx.cwd, l.path).replace(/\\/g, "/") || input.path;
-          return `${rel}:${l.line + 1}:${l.character + 1}`;
-        });
-        return { output: formatted.join("\n") };
-      }
-      const diags = await client.diagnostics(file, 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, join as join4 } 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 = isAbsolute(spec) ? spec : spec.startsWith(".") ? join4(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" };
-var pluginCache = /* @__PURE__ */ new Map();
-function loadPluginsOnce(specs, opts) {
-  const key = JSON.stringify({ specs, home: opts.home, cwd: opts.cwd });
-  const cached = pluginCache.get(key);
-  if (cached) return cached;
-  const loaded = loadPlugins(specs, opts);
-  pluginCache.set(key, loaded);
-  return loaded;
-}
-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);
-  const persistSession = opts.persistSession !== false;
-  let config = loadConfig(opts.cwd, env);
-  let modelRef = opts.args.model ?? config.model;
-  let reasoning = opts.args.reasoning ?? config.reasoning;
-  const makeSingleProvider = (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 makeProvider = (ref) => {
-    const primary = makeSingleProvider(ref);
-    if (opts.provider) return primary;
-    const fallbackRefs = [
-      ...opts.args.fallbackModel ? [opts.args.fallbackModel] : [],
-      ...config.fallbackModels ?? []
-    ].filter((r) => r && r !== ref);
-    if (!fallbackRefs.length) return primary;
-    return withFallbackProvider(
-      primary,
-      () => fallbackRefs.flatMap((fbRef) => {
-        try {
-          return [makeSingleProvider(fbRef)];
-        } catch {
-          return [];
-        }
-      })
-    );
-  };
-  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();
-      if (!opts.args.model) {
-        const prevModel = latest.lastModel();
-        if (prevModel) modelRef = prevModel;
-      }
-    }
-  }
-  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 = loadPluginsOnce(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: () => opts.provider ? agent.provider : makeProvider(modelRef),
-    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) => {
-      if (persistSession) session.append(m);
-    },
-    onUsage: (u) => {
-      if (persistSession) session.appendUsage({ ...u, model: modelRef });
-    },
-    onReset: () => {
-      if (persistSession) 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 };
-      if (!opts.args.model) {
-        const prevModel = previous.lastModel();
-        if (prevModel) {
-          try {
-            const nextProvider = makeProvider(prevModel);
-            modelRef = prevModel;
-            agent.provider = nextProvider;
-            agent.setBudgetModel(prevModel);
-            agent.setContextWindow(contextWindowFor(prevModel, env));
-            agent.setSystemPrompt(systemFor(modelRef));
-          } catch {
-          }
-        }
-      }
-      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.setBudgetModel(ref);
-      agent.setContextWindow(contextWindowFor(ref, env));
-      agent.setSystemPrompt(systemFor(modelRef));
-    },
-    setReasoning(level) {
-      reasoning = level;
-      agent.reasoning = level;
-    }
-  };
-}
-
-export {
-  lunaPtcAutoEnabled,
-  createRuntime
-};