@botconnector/bccli 0.4.0-beta.36 → 0.4.0-beta.37

package/dist/cli.js

@@ -1,51 +1,69 @@
 #!/usr/bin/env node
 import {
   BUILTIN_AGENTS,
+  appendMemory,
+  bashTool,
   buildSystemPrompt,
+  createBashTool,
+  defineTool,
   ignorePatterns,
   loadAgentDefs,
   loadCommands,
   loadSkills,
   normalizeGlobPath,
   parseFrontmatter,
+  resolveWorktree,
+  runHooks,
   runPrint,
   validateGlobPattern
-} from "./chunk-HKHKYFZI.js";
+} from "./chunk-HXSREA7S.js";
 import {
   helpText,
   parseCliArgs
-} from "./chunk-BTCJNE7R.js";
+} from "./chunk-ASTNW3X2.js";
 import {
   Permissions
-} from "./chunk-ELML4KVQ.js";
+} from "./chunk-R3ND76LW.js";
 import {
   addProviderKey,
-  completionAssistantMessage,
-  createProvider,
-  hasPendingProgrammaticReplay,
   listAllModels
-} from "./chunk-QKWSDZJQ.js";
+} from "./chunk-BB4CVWHS.js";
 import {
   providerName,
   readGlobalConfigFile
-} from "./chunk-3DHJO7NC.js";
-import "./chunk-3NTTXK4Y.js";
+} from "./chunk-U66JJ6RN.js";
 import {
   runLogin
-} from "./chunk-NSCC5VMS.js";
+} from "./chunk-FCQCZCKO.js";
 import {
   Session,
   pruneSessions
-} from "./chunk-SJH3YLW4.js";
+} from "./chunk-3JRBXJVB.js";
+import {
+  completionAssistantMessage,
+  createProvider,
+  hasPendingProgrammaticReplay,
+  imageUserMessage
+} from "./chunk-7TABTC32.js";
+import "./chunk-YURAIW7A.js";
+import {
+  FileOAuthProvider,
+  hasStoredTokens
+} from "./chunk-3HCOAJEQ.js";
+import {
+  expandEnvVars
+} from "./chunk-TASYQW7B.js";
 import {
   ConfigError,
   bccliHome,
   loadConfig,
+  resolveModel
+} from "./chunk-H5N4ST6B.js";
+import {
   resolveLanguage,
-  resolveModel,
   setLanguage,
   t
-} from "./chunk-CZMTWXCE.js";
+} from "./chunk-4RMP4CNT.js";
 
 // src/textToolCalls.ts
 var PAIR = /(?:<arg_key>\s*|`)?([A-Za-z_]\w*)(?:\s*<\/arg_key>)?`?\s*(?:=\s*`|<arg_value>)([\s\S]*?)<\/arg_value>/g;
@@ -113,131 +131,11 @@ function recoverTextToolCalls(text, tools) {
 }
 
 // src/tools/index.ts
-import { z as z8 } from "zod";
-
-// src/tools/bash.ts
-import { spawn } from "child_process";
-import { z } from "zod";
-
-// src/tools/types.ts
-function defineTool(tool) {
-  return tool;
-}
-
-// src/tools/bash.ts
-var HALF = 15e3;
-function killProcessTree(pid, platform = process.platform, spawnFn = spawn) {
-  if (platform === "win32") {
-    const killer = spawnFn("taskkill", ["/pid", String(pid), "/T", "/F"]);
-    killer.on("error", () => {
-      try {
-        process.kill(pid);
-      } catch {
-      }
-    });
-    return;
-  }
-  try {
-    process.kill(-pid, "SIGKILL");
-  } catch {
-    try {
-      process.kill(pid, "SIGKILL");
-    } catch {
-    }
-  }
-}
-var active = /* @__PURE__ */ new Set();
-var exitHookInstalled = false;
-function killAllCommands() {
-  for (const kill of active) kill();
-}
-function runCommand(command, opts) {
-  return new Promise((resolve2) => {
-    const child = spawn(command, {
-      cwd: opts.cwd,
-      shell: true,
-      detached: process.platform !== "win32",
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    if (!exitHookInstalled) {
-      process.on("exit", killAllCommands);
-      exitHookInstalled = true;
-    }
-    child.stdout.setEncoding("utf8");
-    child.stderr.setEncoding("utf8");
-    let head = "";
-    let tail = "";
-    let dropped = 0;
-    let timedOut = false;
-    let aborted = false;
-    const onData = (data) => {
-      let s = data;
-      if (head.length < HALF) {
-        const take = s.slice(0, HALF - head.length);
-        head += take;
-        s = s.slice(take.length);
-      }
-      if (s) {
-        tail += s;
-        if (tail.length > HALF) {
-          dropped += tail.length - HALF;
-          tail = tail.slice(-HALF);
-        }
-      }
-    };
-    child.stdout.on("data", onData);
-    child.stderr.on("data", onData);
-    const kill = () => {
-      if (child.pid !== void 0) killProcessTree(child.pid);
-    };
-    const killAsAborted = () => {
-      aborted = true;
-      kill();
-    };
-    active.add(killAsAborted);
-    const timer = setTimeout(() => {
-      timedOut = true;
-      kill();
-    }, opts.timeoutMs);
-    const onAbort = () => {
-      aborted = true;
-      kill();
-    };
-    if (opts.signal.aborted) onAbort();
-    opts.signal.addEventListener("abort", onAbort, { once: true });
-    const finish = (exitCode, extra = "") => {
-      active.delete(killAsAborted);
-      clearTimeout(timer);
-      opts.signal.removeEventListener("abort", onAbort);
-      const output = dropped ? `${head}
-\u2026 [${dropped} characters truncated] \u2026
-${tail}` : head + tail;
-      resolve2({ output: output + extra, exitCode, timedOut, aborted });
-    };
-    child.on("error", (error) => finish(null, error.message));
-    child.on("close", (code) => finish(code));
-  });
-}
-var bashTool = defineTool({
-  name: "bash",
-  description: "Run a shell command in the project directory. No interactive input. Default timeout 2 minutes (max 10). Use for tests, builds, git, and other CLI tasks.",
-  schema: z.object({
-    command: z.string().describe("The shell command to run"),
-    timeout_ms: z.number().int().min(1e3).max(6e5).optional().describe("Timeout in milliseconds")
-  }),
-  kind: "bash",
-  target: (input) => input.command,
-  async run(input, ctx) {
-    const r = await runCommand(input.command, { cwd: ctx.cwd, timeoutMs: input.timeout_ms ?? 12e4, signal: ctx.signal });
-    const status = r.timedOut ? `[stopped: timeout after ${Math.round((input.timeout_ms ?? 12e4) / 1e3)} seconds]` : r.aborted ? "[cancelled by the user]" : `[exit code ${r.exitCode}]`;
-    return { output: `${r.output.trimEnd()}
-${status}`.trimStart(), isError: r.exitCode !== 0 };
-  }
-});
+import { z as z7 } from "zod";
 
 // src/tools/edit.ts
 import { readFile, writeFile } from "fs/promises";
-import { z as z2 } from "zod";
+import { z } from "zod";
 
 // src/diff.ts
 import { structuredPatch } from "diff";
@@ -275,11 +173,11 @@ function errorCode(error) {
 }
 
 // src/tools/edit.ts
-var schema = z2.object({
-  path: z2.string().describe("File path, relative to the project or absolute"),
-  old_string: z2.string().describe("Exact text to replace; must be unique unless replace_all"),
-  new_string: z2.string().describe("Replacement text"),
-  replace_all: z2.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().describe("Exact text to replace; must be unique unless replace_all"),
+  new_string: z.string().describe("Replacement text"),
+  replace_all: z.boolean().optional().describe("Replace every occurrence")
 });
 function countOccurrences(haystack, needle) {
   let count = 0;
@@ -351,7 +249,11 @@ var editTool = defineTool({
 });
 
 // src/tools/fetch.ts
-import { z as z3 } from "zod";
+import { lookup as dnsCbLookup } from "dns";
+import { lookup as dnsLookup } from "dns/promises";
+import { isIP } from "net";
+import { Agent, fetch as undiciFetch } from "undici";
+import { z as z2 } from "zod";
 var MAX_CHARS = 12e3;
 var FOCUS_CHUNKS = 3;
 var FOCUS_SIZE = 800;
@@ -406,6 +308,21 @@ function isPrivateHost(host) {
   return !h.includes(".");
 }
 var words = (s) => s.toLowerCase().match(/[\p{L}\p{N}]{2,}/gu) ?? [];
+function pinLookup(pinned) {
+  return (hostname, options, callback) => {
+    const opts = typeof options === "object" && options !== null ? options : {};
+    const family = typeof options === "number" ? options : opts.family;
+    const realDns = () => dnsCbLookup(hostname, typeof options === "number" ? { family: options } : opts, callback);
+    if (!pinned.length) return realDns();
+    const list = family ? pinned.filter((a) => a.family === family) : pinned;
+    if (!list.length) {
+      callback(Object.assign(new Error(`no pinned address for family ${family}`), { code: "ENOTFOUND" }), "");
+      return;
+    }
+    if (opts.all) callback(null, list);
+    else callback(null, list[0].address, list[0].family);
+  };
+}
 function pickRelevant(text, query, count = FOCUS_CHUNKS, size = FOCUS_SIZE) {
   const chunks = [];
   let cur = "";
@@ -456,22 +373,38 @@ var withCost = (text, what) => `${what} \xB7 ${t("~{n} tokens", { n: tokensOf(te
 function createFetchTool(opts = {}) {
   const keenableURL = opts.keenableURL === void 0 ? "https://api.keenable.ai/v1/fetch/public" : opts.keenableURL;
   const isPrivate = opts.isPrivate ?? isPrivateHost;
+  const lookup = opts.lookup ?? ((hostname) => dnsLookup(hostname, { all: true }));
   return defineTool({
     name: "fetch",
     description: `Fetch a URL (http/https) as text/markdown. Costs the user tokens, so ask for as little as you need:
 - Pass \`prompt\` (what you want to know from the page) to get only the relevant excerpt instead of the whole page. Prefer this whenever you are looking for specific facts.
 - Without \`prompt\` you get the first ${MAX_CHARS} characters; the reply tells you the \`offset\` to continue from.
 - Fetching a page that is already in this conversation is wasteful; reuse what you have.`,
-    schema: z3.object({
-      url: z3.string().describe("Absolute http(s) URL"),
-      prompt: z3.string().max(2e3).optional().describe("What to look for in the page; returns only the relevant excerpt"),
-      offset: z3.number().int().min(0).optional().describe("Start reading at this character (to continue a truncated page)")
+    schema: z2.object({
+      url: z2.string().describe("Absolute http(s) URL"),
+      prompt: z2.string().max(2e3).optional().describe("What to look for in the page; returns only the relevant excerpt"),
+      offset: z2.number().int().min(0).optional().describe("Start reading at this character (to continue a truncated page)")
     }),
     kind: "fetch",
     target: (input) => input.url,
     async run(input, ctx) {
       if (!/^https?:\/\//i.test(input.url)) return { output: "URL must start with http:// or https://", isError: true };
       const target = new URL(input.url);
+      let pinned;
+      if (!isPrivate(target.hostname) && isIP(target.hostname) === 0) {
+        try {
+          const addresses = await lookup(target.hostname);
+          const internal = addresses.find((a) => isPrivate(a.address));
+          if (internal) {
+            return {
+              output: t("Blocked: {host} resolves to a private address ({addr}). Fetching an internal host through a public DNS name is not allowed.", { host: target.hostname, addr: internal.address }),
+              isError: true
+            };
+          }
+          pinned = addresses;
+        } catch {
+        }
+      }
       const prompt = input.prompt?.trim();
       const askKeenable = !!prompt && !input.offset && !!keenableURL && !target.username && !target.password && !isPrivate(target.hostname);
       if (askKeenable) {
@@ -496,7 +429,7 @@ ${input.url}`);
       const cached = !!page;
       if (cached) ctx.refundFetch?.();
       if (!page) {
-        const loaded = await loadPage(input.url, ctx.signal);
+        const loaded = await loadPage(input.url, ctx.signal, pinned, opts.fetchPage);
         if ("error" in loaded) return { output: loaded.error, isError: true };
         page = loaded;
         remember(`p
@@ -543,12 +476,19 @@ async function extractWithKeenable(endpoint, url, prompt, signal) {
     return void 0;
   }
 }
-async function loadPage(inputUrl, signal) {
+async function loadPage(inputUrl, signal, pinned, fetchPage) {
   let url = new URL(inputUrl);
-  let res;
+  const dispatcher = pinned?.length ? new Agent({ connect: { lookup: pinLookup(pinned) } }) : void 0;
+  const doFetch = fetchPage ?? (dispatcher ? undiciFetch : fetch);
   try {
+    let res;
     for (let hop = 0; hop < 5; hop++) {
-      res = await fetch(url, { headers: { accept: ACCEPT }, signal: AbortSignal.any([signal, AbortSignal.timeout(3e4)]), redirect: "manual" });
+      res = await doFetch(url, {
+        headers: { accept: ACCEPT },
+        signal: AbortSignal.any([signal, AbortSignal.timeout(3e4)]),
+        redirect: "manual",
+        ...dispatcher ? { dispatcher } : {}
+      });
       const location = res.status >= 300 && res.status < 400 ? res.headers.get("location") : null;
       if (!location) break;
       const next = new URL(location, url);
@@ -559,21 +499,24 @@ async function loadPage(inputUrl, signal) {
       await res.body?.cancel();
       url = next;
     }
+    if (!res) return { error: `Failed to fetch ${inputUrl}` };
+    const { text: body, truncated } = await readCapped(res);
+    const type = res.headers.get("content-type") ?? "";
+    const text = type.includes("html") ? htmlToText(body) : body;
+    if (!res.ok) return { error: `HTTP ${res.status} from ${inputUrl}: ${text.slice(0, 500)}` };
+    return { text, truncated, at: Date.now() };
   } catch (error) {
     return { error: `Failed to fetch ${inputUrl}: ${describeFetchError(error)}` };
+  } finally {
+    await dispatcher?.close().catch(() => {
+    });
   }
-  if (!res) return { error: `Failed to fetch ${inputUrl}` };
-  const { text: body, truncated } = await readCapped(res);
-  const type = res.headers.get("content-type") ?? "";
-  const text = type.includes("html") ? htmlToText(body) : body;
-  if (!res.ok) return { error: `HTTP ${res.status} from ${inputUrl}: ${text.slice(0, 500)}` };
-  return { text, truncated, at: Date.now() };
 }
 var fetchTool = createFetchTool();
 
 // src/tools/glob.ts
 import { glob as nativeGlob } from "fs/promises";
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 
 // src/abort.ts
 var ABORTED = /* @__PURE__ */ Symbol("aborted");
@@ -614,9 +557,9 @@ 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: z4.object({
-    pattern: z4.string().describe("Glob pattern"),
-    path: z4.string().optional().describe("Base directory, default project root")
+  schema: z3.object({
+    pattern: z3.string().describe("Glob pattern"),
+    path: z3.string().optional().describe("Base directory, default project root")
   }),
   kind: "read",
   target: (input) => input.pattern,
@@ -654,7 +597,7 @@ var globTool = defineTool({
 import { execFile } from "child_process";
 import { readFile as readFile2 } from "fs/promises";
 import { glob as nativeGlob2 } from "fs/promises";
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 var MAX_MATCHES = 200;
 var MAX_OUTPUT_CHARS2 = 24e3;
 async function grepJs(pattern, opts) {
@@ -703,11 +646,11 @@ function grepRg(pattern, opts) {
 var grepTool = defineTool({
   name: "grep",
   description: "Search file contents with a regular expression. Respects .gitignore. Returns path:line:text (max 200).",
-  schema: z5.object({
-    pattern: z5.string().describe("Regular expression"),
-    path: z5.string().optional().describe("Directory to search, default project root"),
-    glob: z5.string().optional().describe('Only files matching this glob, e.g. "**/*.ts"'),
-    ignore_case: z5.boolean().optional()
+  schema: z4.object({
+    pattern: z4.string().describe("Regular expression"),
+    path: z4.string().optional().describe("Directory to search, default project root"),
+    glob: z4.string().optional().describe('Only files matching this glob, e.g. "**/*.ts"'),
+    ignore_case: z4.boolean().optional()
   }),
   kind: "read",
   target: (input) => input.pattern,
@@ -743,71 +686,120 @@ var grepTool = defineTool({
 
 // src/tools/read.ts
 import { readFile as readFile3 } from "fs/promises";
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
 var MAX_LINE = 2e3;
 var MAX_OUTPUT_CHARS3 = 4e4;
-var readTool = defineTool({
-  name: "read",
-  description: "Read a text file. Returns numbered lines (default first 2000). Use offset/limit for large files. Always read a file before editing it.",
-  schema: z6.object({
-    path: z6.string().describe("File path, relative to the project or absolute"),
-    offset: z6.number().int().min(1).optional().describe("First line to read, 1-based"),
-    limit: z6.number().int().min(1).optional().describe("Number of lines, default 2000")
-  }),
-  kind: "read",
-  target: (input) => input.path,
-  async run(input, ctx) {
-    const abs = resolvePath(ctx.cwd, input.path);
-    let buffer;
-    try {
-      buffer = await readFile3(abs);
-    } catch (error) {
-      return { output: `Cannot read ${input.path}: ${errorCode(error)}`, isError: true };
-    }
-    if (buffer.subarray(0, 8e3).includes(0)) {
-      return { output: `${input.path} is a binary file; not read.`, isError: true };
-    }
-    const lines = buffer.toString("utf8").split(/\r?\n/);
-    const start = (input.offset ?? 1) - 1;
-    const limit = input.limit ?? 2e3;
-    const requested = lines.slice(start, start + limit);
-    const shown = [];
-    let size = 0;
-    for (let i = 0; i < requested.length; i++) {
-      const line = requested[i];
-      const text = line.length > MAX_LINE ? `${line.slice(0, MAX_LINE)}\u2026 [line truncated]` : line;
-      const rendered = `${String(start + i + 1).padStart(6)}	${text}`;
-      const extra = rendered.length + (shown.length ? 1 : 0);
-      if (shown.length && size + extra > MAX_OUTPUT_CHARS3) break;
-      shown.push(rendered);
-      size += extra;
-      if (size >= MAX_OUTPUT_CHARS3) break;
-    }
-    const body = shown.join("\n");
-    const remaining = lines.length - start - shown.length;
-    const tokenBudgetHit = shown.length < requested.length;
-    const nextOffset = start + shown.length + 1;
-    ctx.readFiles.add(abs);
+var MAX_IMAGE_BYTES = 4 * 1024 * 1024;
+var IMAGE_HEADERS = [
+  {
+    mediaType: "image/png",
+    match: (h) => h.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))
+  },
+  { mediaType: "image/jpeg", match: (h) => h[0] === 255 && h[1] === 216 && h[2] === 255 },
+  { mediaType: "image/gif", match: (h) => h.subarray(0, 6).toString("ascii").startsWith("GIF8") },
+  {
+    mediaType: "image/webp",
+    match: (h) => h.subarray(0, 4).toString("ascii") === "RIFF" && h.subarray(8, 12).toString("ascii") === "WEBP"
+  }
+];
+var MEDIA_LABEL = {
+  "image/png": "png",
+  "image/jpeg": "jpeg",
+  "image/gif": "gif",
+  "image/webp": "webp"
+};
+function imageMediaType(buffer) {
+  return IMAGE_HEADERS.find((entry) => entry.match(buffer))?.mediaType;
+}
+var schema2 = z5.object({
+  path: z5.string().describe("File path, relative to the project or absolute"),
+  offset: z5.number().int().min(1).optional().describe("First line to read, 1-based"),
+  limit: z5.number().int().min(1).optional().describe("Number of lines, default 2000")
+});
+async function readImageResult(input, buffer, mediaType) {
+  if (buffer.length > MAX_IMAGE_BYTES) {
     return {
-      output: 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 })
+      output: `Cannot attach ${input.path}: image is ${(buffer.length / (1024 * 1024)).toFixed(1)} MB (limit 4 MB).`,
+      isError: true
     };
   }
-});
+  const label = MEDIA_LABEL[mediaType] ?? mediaType;
+  return {
+    output: `[image attached] ${input.path} (${label}, ${(buffer.length / 1024).toFixed(1)} KB).`,
+    display: `${input.path} \xB7 image`,
+    images: [{ mediaType, data: buffer.toString("base64"), path: input.path }]
+  };
+}
+async function readTextResult(input, buffer) {
+  const lines = buffer.toString("utf8").split(/\r?\n/);
+  const start = (input.offset ?? 1) - 1;
+  const limit = input.limit ?? 2e3;
+  const requested = lines.slice(start, start + limit);
+  const shown = [];
+  let size = 0;
+  for (let i = 0; i < requested.length; i++) {
+    const line = requested[i];
+    const text = line.length > MAX_LINE ? `${line.slice(0, MAX_LINE)}\u2026 [line truncated]` : line;
+    const rendered = `${String(start + i + 1).padStart(6)}	${text}`;
+    const extra = rendered.length + (shown.length ? 1 : 0);
+    if (shown.length && size + extra > MAX_OUTPUT_CHARS3) break;
+    shown.push(rendered);
+    size += extra;
+    if (size >= MAX_OUTPUT_CHARS3) break;
+  }
+  const body = shown.join("\n");
+  const remaining = lines.length - start - shown.length;
+  const tokenBudgetHit = shown.length < requested.length;
+  const nextOffset = start + shown.length + 1;
+  return {
+    output: remaining > 0 ? tokenBudgetHit ? `${body}
+\u2026 ${remaining} more lines (token budget reached; continue with offset=${nextOffset})` : `${body}
+\u2026 ${remaining} more lines (use offset)` : body,
+    display: t("{n} lines", { n: shown.length })
+  };
+}
+function createReadTool(options = {}) {
+  const vision = options.vision !== false;
+  return defineTool({
+    name: "read",
+    description: vision ? "Read a text file, or an image (png/jpeg/gif/webp) which is attached for the model to see. Returns numbered lines (default first 2000). Use offset/limit for large files. Always read a file before editing it." : "Read a text file. Returns numbered lines (default first 2000). Use offset/limit for large files. Always read a file before editing it.",
+    schema: schema2,
+    kind: "read",
+    target: (input) => input.path,
+    async run(input, ctx) {
+      const abs = resolvePath(ctx.cwd, input.path);
+      let buffer;
+      try {
+        buffer = await readFile3(abs);
+      } catch (error) {
+        return { output: `Cannot read ${input.path}: ${errorCode(error)}`, isError: true };
+      }
+      const mediaType = vision ? imageMediaType(buffer) : void 0;
+      if (mediaType) {
+        ctx.readFiles.add(abs);
+        return readImageResult(input, buffer, mediaType);
+      }
+      if (buffer.subarray(0, 8e3).includes(0)) {
+        return { output: `${input.path} is a binary file; not read.`, isError: true };
+      }
+      ctx.readFiles.add(abs);
+      return readTextResult(input, buffer);
+    }
+  });
+}
+var readTool = createReadTool({ vision: true });
 
 // src/tools/write.ts
 import { existsSync } from "fs";
 import { mkdir, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
 import { dirname } from "path";
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 var writeTool = defineTool({
   name: "write",
   description: "Create or overwrite a file with the given content. Read an existing file first. Prefer edit for changes.",
-  schema: z7.object({
-    path: z7.string().describe("File path, relative to the project or absolute"),
-    content: z7.string().describe("Full new file content")
+  schema: z6.object({
+    path: z6.string().describe("File path, relative to the project or absolute"),
+    content: z6.string().describe("Full new file content")
   }),
   kind: "edit",
   target: (input) => input.path,
@@ -842,7 +834,7 @@ var writeTool = defineTool({
 var ALL_TOOLS = [readTool, writeTool, editTool, bashTool, grepTool, globTool, fetchTool];
 function toolDefinitions(tools) {
   return tools.map((tool) => {
-    const { $schema: _ignored, ...parameters } = tool.jsonSchema ?? z8.toJSONSchema(tool.schema);
+    const { $schema: _ignored, ...parameters } = tool.jsonSchema ?? z7.toJSONSchema(tool.schema);
     return { type: "function", function: { name: tool.name, description: tool.description, parameters, ...tool.outputJsonSchema ? { output_schema: tool.outputJsonSchema } : {} } };
   });
 }
@@ -921,11 +913,23 @@ var WebBudget = class {
   }
 };
 
+// src/tokenBudget.ts
+var estimateTokens = (text) => Math.ceil(text.length / 4);
+var estimateMessages = (messages) => estimateTokens(JSON.stringify(messages));
+function trimToFit(messages, maxTokens) {
+  let out = messages;
+  while (estimateMessages(out) > maxTokens) {
+    const boundary = out.findIndex((m, i) => i > 0 && m.role === "user");
+    if (boundary === -1) return out;
+    out = out.slice(boundary);
+  }
+  return out;
+}
+
 // src/agent.ts
 var CANCELLED = "Cancelled by the user.";
-var estimateTokens = (text) => Math.ceil(text.length / 4);
 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 {
+var Agent2 = class {
   constructor(opts) {
     this.opts = opts;
     this.provider = opts.provider;
@@ -958,12 +962,15 @@ var Agent = class {
   readFiles = /* @__PURE__ */ new Set();
   webBudget = new WebBudget();
   maxSteps;
-  // ponytail: one window for every model; read it from /v1/models metadata when providers expose it.
+  // One window for every model; resolved from contextWindowFor() (catalog + env override).
   contextWindow;
   systemPrompt;
   setSystemPrompt(text) {
     this.systemPrompt = text;
   }
+  setContextWindow(window) {
+    this.contextWindow = window;
+  }
   setTools(tools) {
     this.tools = tools;
     this.definitions = toolDefinitions(tools);
@@ -987,7 +994,7 @@ var Agent = class {
     this.messages = messages;
     this.readFiles.clear();
     this.webBudget.reset();
-    this.lastInputTokens = 0;
+    this.lastInputTokens = estimateMessages(messages) + estimateTokens(this.systemPrompt);
   }
   clear() {
     this.messages = [];
@@ -997,8 +1004,9 @@ var Agent = class {
     this.opts.onReset?.();
   }
   async compact(signal) {
+    const history = trimToFit(this.messages, Math.floor(this.contextWindow * 0.8));
     const completion = await this.provider.chat({
-      messages: [{ role: "system", content: this.systemPrompt }, ...this.messages, { role: "user", content: COMPACT_PROMPT }],
+      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,
@@ -1076,6 +1084,7 @@ ${completion.text}` });
         }
         const calls = completion.toolCalls;
         let i = 0;
+        const roundImages = [];
         while (i < calls.length) {
           if (signal.aborted) {
             this.cancelCalls(calls.slice(i));
@@ -1101,15 +1110,17 @@ ${completion.text}` });
             return;
           }
           batch.forEach((c, k) => {
+            roundImages.push(...outcome[k].images ?? []);
             this.push({
               role: "tool",
               tool_call_id: c.id,
-              content: outcome[k],
+              content: outcome[k].output,
               ...c.caller ? { responses_caller: c.caller } : {}
             });
           });
           i = j;
         }
+        if (roundImages.length) this.push(imageUserMessage(roundImages));
         if (signal.aborted) {
           this.onEvent({ type: "aborted" });
           return;
@@ -1140,12 +1151,31 @@ ${t("This model may not support tool calling. Try another model with /model.")}`
         ...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;
+      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(", ")}`);
@@ -1163,6 +1193,9 @@ ${t("This model may not support tool calling. Try another model with /model.")}`
     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,
@@ -1184,7 +1217,7 @@ ${t("This model may not support tool calling. Try another model with /model.")}`
     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 invalid;
+      return { output: invalid };
     }
     const request = { tool: tool.name, kind: tool.kind, target };
     let decision = this.permissions.check(request);
@@ -1203,7 +1236,7 @@ ${t("This model may not support tool calling. Try another model with /model.")}`
     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;
+      return { output };
     }
     let result;
     try {
@@ -1212,8 +1245,15 @@ ${t("This model may not support tool calling. Try another model with /model.")}`
       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.output;
+    return result;
   }
 };
 
@@ -1222,6 +1262,25 @@ import { existsSync as existsSync2, statSync } from "fs";
 import { readFile as readFile5, rm, writeFile as writeFile3 } from "fs/promises";
 var MAX_TURNS = 20;
 var MAX_BYTES2 = 2 * 1024 * 1024;
+function emptyResult() {
+  return { restored: [], deleted: [], skipped: [], failed: [] };
+}
+async function restoreTurn(turn, result) {
+  for (const [path, original] of turn) {
+    try {
+      if (original === "skipped") result.skipped.push(path);
+      else if (original === null) {
+        await rm(path, { force: true });
+        result.deleted.push(path);
+      } else {
+        await writeFile3(path, original);
+        result.restored.push(path);
+      }
+    } catch {
+      result.failed.push(path);
+    }
+  }
+}
 var CheckpointStore = class {
   history = [];
   current;
@@ -1243,27 +1302,37 @@ var CheckpointStore = class {
   turns() {
     return this.history.filter((t2) => t2.size).length;
   }
+  /** Total entries including empty ones; used to align file snapshots with conversation turns. */
+  entries() {
+    return this.history.length;
+  }
   async undo() {
     while (this.history.length && !this.history.at(-1)?.size) this.history.pop();
     const turn = this.history.pop();
     this.current = void 0;
     if (!turn) return void 0;
-    const result = { restored: [], deleted: [], skipped: [], failed: [] };
-    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);
+    const result = emptyResult();
+    await restoreTurn(turn, result);
+    return result;
+  }
+  /**
+   * Revert every snapshot taken at or after the `keep`-th entry, newest first, so the files
+   * end in the state from before the turn that created entry `keep`. Used by /rewind, which
+   * pairs conversation turns with the entry count recorded when each turn started.
+   */
+  async undoTo(keep) {
+    const target = Math.max(0, Math.min(keep, this.history.length));
+    const result = emptyResult();
+    let applied = false;
+    while (this.history.length > target) {
+      const turn = this.history.pop();
+      if (turn?.size) {
+        await restoreTurn(turn, result);
+        applied = true;
       }
     }
-    return result;
+    this.current = void 0;
+    return applied ? result : void 0;
   }
   clear() {
     this.history.length = 0;
@@ -1271,12 +1340,66 @@ var CheckpointStore = class {
   }
 };
 
+// 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 z9 } from "zod";
+import { z as z8 } from "zod";
 var MCP_OUTPUT_MAX_CHARS = 32e3;
+var CHILD_ENV_KEYS = [
+  // portable
+  "PATH",
+  "HOME",
+  "USERPROFILE",
+  "LANG",
+  "LC_ALL",
+  "TZ",
+  "TMP",
+  "TEMP",
+  "TMPDIR",
+  // windows
+  "SYSTEMROOT",
+  "SYSTEMDRIVE",
+  "COMSPEC",
+  "PATHEXT",
+  "APPDATA",
+  "LOCALAPPDATA",
+  "HOMEDRIVE",
+  "HOMEPATH",
+  "USERNAME",
+  "PROGRAMFILES",
+  "PROCESSOR_ARCHITECTURE",
+  // posix
+  "LOGNAME",
+  "SHELL",
+  "TERM",
+  "USER"
+];
+function mcpChildEnv(extra) {
+  const env = {};
+  for (const key of CHILD_ENV_KEYS) {
+    const value = process.env[key];
+    if (value !== void 0) env[key] = value;
+  }
+  return { ...env, ...extra };
+}
 function mcpToolName(server, tool, taken) {
   const clean2 = (s) => s.replace(/[^A-Za-z0-9_-]+/g, "_");
   const base = `mcp__${clean2(server)}__${clean2(tool)}`.slice(0, 64);
@@ -1311,13 +1434,22 @@ var McpManager = class {
     entry.client = client;
     const timeoutMs = this.opts.connectTimeoutMs ?? 3e4;
     try {
-      const config = spec.config;
-      const transport = config.type === "http" ? new StreamableHTTPClientTransport(new URL(config.url), { requestInit: { headers: config.headers ?? {} } }) : new StdioClientTransport({
-        command: config.command,
-        args: config.args ?? [],
-        env: { ...process.env, ...config.env },
-        stderr: "ignore"
-      });
+      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) {
@@ -1328,7 +1460,15 @@ var McpManager = class {
       entry.tools = tools.map((t2) => this.wrap(spec.name, client, t2));
       entry.state = { ...entry.state, status: "ready", tools: entry.tools.length };
     } catch (error) {
-      entry.state = { ...entry.state, status: "error", error: error.message };
+      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;
@@ -1339,7 +1479,7 @@ var McpManager = class {
     return {
       name: mcpToolName(server, tool.name, this.taken),
       description: `[MCP ${server}] ${tool.description ?? tool.name}`.slice(0, 1024),
-      schema: z9.record(z9.string(), z9.unknown()),
+      schema: z8.record(z8.string(), z8.unknown()),
       jsonSchema: tool.inputSchema,
       ...tool.outputSchema ? { outputJsonSchema: tool.outputSchema } : {},
       kind: "mcp",
@@ -1388,12 +1528,12 @@ var McpManager = class {
 import { homedir } from "os";
 
 // src/tools/plan.ts
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
 function createExitPlanTool(opts) {
   return defineTool({
     name: "exit_plan",
     description: "Plan mode only: present the finished plan to the user for approval. If approved you may start implementing it.",
-    schema: z10.object({ plan: z10.string().describe("The plan, in markdown") }),
+    schema: z9.object({ plan: z9.string().describe("The plan, in markdown") }),
     kind: "read",
     target: () => t("plan"),
     async run(input) {
@@ -1410,12 +1550,12 @@ function createExitPlanTool(opts) {
 
 // src/tools/skill.ts
 import { readFileSync } from "fs";
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 function createSkillTool(skills) {
   return defineTool({
     name: "skill",
     description: "Load a skill (instructions for a kind of task) by name. Use it when a listed skill matches the task, then follow it.",
-    schema: z11.object({ name: z11.string().describe("Skill name from the list in the system prompt") }),
+    schema: z10.object({ name: z10.string().describe("Skill name from the list in the system prompt") }),
     kind: "read",
     target: (input) => input.name,
     async run(input) {
@@ -1430,7 +1570,7 @@ ${body}`, display: skill.description.slice(0, 60) };
 }
 
 // src/tools/websearch.ts
-import { z as z12 } from "zod";
+import { z as z11 } from "zod";
 var clean = (items, max) => (Array.isArray(items) ? items : []).filter((r) => typeof r?.url === "string" && /^https?:\/\//.test(r.url)).slice(0, max).map((r) => ({
   title: String(r.title || r.url).slice(0, 200),
   url: r.url,
@@ -1451,9 +1591,9 @@ function createWebSearchTool(opts) {
   return defineTool({
     name: "web_search",
     description: "Search the web. Returns titles, URLs and short snippets. Use it to find the right pages instead of guessing URLs; then fetch a result URL when you need the full page.",
-    schema: z12.object({
-      query: z12.string().min(1).max(500).describe("Search query"),
-      max_results: z12.number().int().min(1).max(10).optional().describe("Number of results (default 6)")
+    schema: z11.object({
+      query: z11.string().min(1).max(500).describe("Search query"),
+      max_results: z11.number().int().min(1).max(10).optional().describe("Number of results (default 6)")
     }),
     kind: "read",
     target: (input) => input.query,
@@ -1491,27 +1631,41 @@ function createWebSearchTool(opts) {
 }
 
 // src/tools/task.ts
-import { z as z13 } from "zod";
+import { z as z12 } from "zod";
 function createTaskTool(opts) {
   const byName = new Map(opts.agents.map((a) => [a.name, a]));
   const list = opts.agents.map((a) => `- ${a.name}: ${a.description}`).join("\n");
+  let askChain = Promise.resolve();
+  const enqueueAsk = (fn) => {
+    const next = askChain.then(
+      () => fn(),
+      () => fn()
+    );
+    askChain = next.then(
+      () => void 0,
+      () => void 0
+    );
+    return next;
+  };
   return defineTool({
     name: "task",
     description: `Delegate a self-contained sub-task to a subagent. It starts with an empty context and returns only its final report. Available agents:
 ${list}`,
-    schema: z13.object({
-      agent: z13.string().describe("Agent name"),
-      description: z13.string().describe("3-6 word summary shown to the user"),
-      prompt: z13.string().describe("Full instructions; the subagent sees nothing else")
+    schema: z12.object({
+      agent: z12.string().describe("Agent name"),
+      description: z12.string().describe("3-6 word summary shown to the user"),
+      prompt: z12.string().describe("Full instructions; the subagent sees nothing else")
     }),
     kind: "read",
     target: (input) => `[${input.agent}] ${input.description}`,
-    // Parallel only when the resolved agent can do nothing but read (a project file may redefine "explore").
+    // parallel: true opts a write-capable agent in; otherwise only all-read agents run concurrently
+    // (a project file may redefine "explore").
     parallelSafe: (input) => {
-      const allowed = byName.get(input.agent)?.tools;
-      if (!allowed) return false;
+      const def = byName.get(input.agent);
+      if (def?.parallel) return true;
+      if (!def?.tools) return false;
       const base = opts.baseTools();
-      return allowed.every((name) => base.find((t2) => t2.name === name)?.kind === "read");
+      return def.tools.every((name) => base.find((t2) => t2.name === name)?.kind === "read");
     },
     async run(input, ctx) {
       const def = byName.get(input.agent);
@@ -1527,7 +1681,7 @@ ${list}`,
       } catch (error) {
         return { output: `Agent "${def.name}": ${error.message}`, isError: true };
       }
-      const child = new Agent({
+      const child = new Agent2({
         provider,
         tools,
         permissions: opts.permissions,
@@ -1536,9 +1690,13 @@ ${list}`,
 # Your role
 ${def.prompt}`,
         cwd: opts.cwd,
-        maxSteps: def.maxSteps,
+        // 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
       });
@@ -1549,7 +1707,8 @@ ${def.prompt}`,
         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 });
       };
-      if (ctx.ask) child.askPermission = ctx.ask;
+      const ask = ctx.ask;
+      if (ask) child.askPermission = (req) => enqueueAsk(() => ask(req));
       await child.run(input.prompt, ctx.signal);
       ctx.addUsage?.(child.totalUsage);
       const tokens2 = child.totalUsage.inputTokens + child.totalUsage.outputTokens;
@@ -1567,7 +1726,7 @@ ${def.prompt}`,
 }
 
 // src/tools/todo.ts
-import { z as z14 } from "zod";
+import { z as z13 } from "zod";
 var TodoStore = class {
   items = [];
   listeners = /* @__PURE__ */ new Set();
@@ -1584,8 +1743,8 @@ 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: z14.object({
-      todos: z14.array(z14.object({ content: z14.string(), status: z14.enum(["pending", "in_progress", "completed"]) }))
+    schema: z13.object({
+      todos: z13.array(z13.object({ content: z13.string(), status: z13.enum(["pending", "in_progress", "completed"]) }))
     }),
     kind: "read",
     target: (input) => `${input.todos.length} item`,
@@ -1600,6 +1759,124 @@ function createTodoTool(store) {
   });
 }
 
+// src/tools/memory.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { join } from "path";
+import { z as z14 } from "zod";
+function createSaveMemoryTool(opts) {
+  return defineTool({
+    name: "save_memory",
+    description: 'Save a durable fact, decision, or convention to the instruction files so future sessions remember it. Scope "project" (default) appends to AGENTS.md in the project; "global" appends to your personal BCCLI.md. Use for things worth remembering across sessions, not temporary task notes.',
+    schema: z14.object({
+      content: z14.string().min(1).max(500).describe("One short line, without a leading bullet (it is added for you)"),
+      scope: z14.enum(["project", "global"]).optional().describe("project (default) or global")
+    }),
+    kind: "edit",
+    target: (input) => `${input.scope ?? "project"} memory`,
+    async run(input, ctx) {
+      const content = input.content.trim();
+      if (!content) return { output: "Memory content is empty.", isError: true };
+      const file = input.scope === "global" ? join(opts.home, "BCCLI.md") : join(ctx.cwd, "AGENTS.md");
+      if (existsSync3(file)) {
+        const lines = readFileSync2(file, "utf8").split("\n");
+        if (lines.some((line) => line.trim() === `- ${content}`)) {
+          return { output: `Already saved to ${file}.` };
+        }
+      }
+      appendMemory(file, content);
+      opts.onSaved?.();
+      return { output: `Saved to ${file}.` };
+    }
+  });
+}
+
+// src/plugins.ts
+import { existsSync as existsSync4 } from "fs";
+import { createRequire } from "module";
+import { isAbsolute as isAbsolute2, join as join2 } from "path";
+import { z as z15 } from "zod";
+var require_ = createRequire(import.meta.url);
+function pluginLog(message) {
+  process.stderr.write(`[plugin] ${message}
+`);
+}
+function normalizeTool(def) {
+  return {
+    name: def.name,
+    description: def.description,
+    // Raw-args passthrough: a plugin without its own zod still receives what the model sent.
+    schema: def.schema ?? z15.record(z15.string(), z15.unknown()),
+    kind: def.kind ?? "read",
+    target: def.target ?? (() => def.name),
+    run: def.run
+  };
+}
+function loadPlugins(specs, opts) {
+  const tools = [];
+  const taken = new Set(opts.builtinNames);
+  const listeners = /* @__PURE__ */ new Map();
+  for (const spec of specs) {
+    let file;
+    try {
+      file = isAbsolute2(spec) ? spec : spec.startsWith(".") ? join2(opts.home, spec) : require_.resolve(spec);
+    } catch {
+      throw new ConfigError(t("Plugin not found: {spec}", { spec }));
+    }
+    if (!existsSync4(file)) throw new ConfigError(t("Plugin not found: {spec}", { spec }));
+    let mod;
+    try {
+      mod = require_(file);
+    } catch (error) {
+      throw new ConfigError(t("Plugin failed to load: {spec}: {reason}", { spec, reason: error.message }));
+    }
+    const activate = typeof mod.default === "function" ? mod.default : typeof mod.activate === "function" ? mod.activate : void 0;
+    if (!activate) {
+      throw new ConfigError(t("Plugin failed to load: {spec}: {reason}", { spec, reason: "no default or activate export" }));
+    }
+    const ctx = {
+      cwd: opts.cwd,
+      env: opts.env,
+      config: opts.config,
+      registerTool(tool) {
+        if (taken.has(tool.name)) {
+          throw new ConfigError(
+            t("Plugin {spec} registered a tool name that is already in use: {name}", { spec, name: tool.name })
+          );
+        }
+        taken.add(tool.name);
+        tools.push(normalizeTool(tool));
+      },
+      on(event, handler) {
+        const list = listeners.get(event) ?? [];
+        list.push(handler);
+        listeners.set(event, list);
+      },
+      log: pluginLog
+    };
+    try {
+      const result = activate(ctx);
+      if (result && typeof result.catch === "function") {
+        ;
+        result.catch((error) => pluginLog(`activation error in ${spec}: ${String(error)}`));
+      }
+    } catch (error) {
+      throw new ConfigError(t("Plugin failed to load: {spec}: {reason}", { spec, reason: error.message }));
+    }
+  }
+  return {
+    tools,
+    async emit(event, payload = {}) {
+      for (const handler of listeners.get(event) ?? []) {
+        try {
+          await handler(payload);
+        } catch (error) {
+          pluginLog(`handler for ${event} failed: ${String(error)}`);
+        }
+      }
+    }
+  };
+}
+
 // src/setup.ts
 var TOOL_RULES = { bash: "bash", edit: "edit", write: "edit", fetch: "fetch" };
 function lunaPtcAutoEnabled(env) {
@@ -1632,6 +1909,8 @@ function createRuntime(opts) {
   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);
@@ -1654,7 +1933,27 @@ function createRuntime(opts) {
       }
     }
   });
-  const baseTools = [...ALL_TOOLS, webSearch, createSkillTool(skills), createTodoTool(todos), createExitPlanTool({ permissions, interaction })];
+  const rebuildPrompt = () => agent.setSystemPrompt(buildSystemPrompt({ cwd: opts.cwd, home, model: modelRef, skills }));
+  const saveMemory = createSaveMemoryTool({ home, onSaved: rebuildPrompt });
+  const baseTools = [
+    createReadTool({ vision: config.vision }),
+    createBashTool({ networkPolicy: config.networkPolicy }),
+    ...ALL_TOOLS.filter((tool) => tool.name !== "read" && tool.name !== "bash"),
+    webSearch,
+    createSkillTool(skills),
+    createTodoTool(todos),
+    createExitPlanTool({ permissions, interaction }),
+    saveMemory
+  ];
+  const plugins = loadPlugins(config.plugins ?? [], {
+    home,
+    cwd: opts.cwd,
+    env,
+    config,
+    builtinNames: [...baseTools.map((tool) => tool.name), "task"]
+  });
+  baseTools.push(...plugins.tools);
+  const pluginEmit = (event, payload) => plugins.emit(event, payload);
   const task = createTaskTool({
     agents: [...BUILTIN_AGENTS, ...agentDefs],
     // Subagents get whatever the main agent has right now (incl. MCP tools), minus task itself.
@@ -1664,9 +1963,12 @@ function createRuntime(opts) {
     providerFor: makeProvider,
     systemPrompt: (childModelRef) => buildSystemPrompt({ cwd: opts.cwd, home, model: childModelRef ?? modelRef, skills }),
     cwd: opts.cwd,
-    reasoning: () => reasoning
+    reasoning: () => reasoning,
+    hooks: config.hooks,
+    pluginEmit,
+    env
   });
-  const agent = new Agent({
+  const agent = new Agent2({
     provider,
     tools: [...baseTools, task],
     permissions,
@@ -1675,12 +1977,25 @@ function createRuntime(opts) {
     history,
     reasoning,
     maxSteps: config.maxSteps,
+    hooks: config.hooks,
+    pluginEmit,
+    env,
+    contextWindow: contextWindowFor(modelRef, env),
     onMessage: (m) => session.append(m),
     onReset: () => session.reset(),
-    onTurnStart: () => checkpoints.beginTurn(),
+    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) => {
@@ -1729,6 +2044,8 @@ function createRuntime(opts) {
       agent.totalUsage = { inputTokens: 0, outputTokens: 0 };
       todos.set([]);
       checkpoints.clear();
+      turnMarks.length = 0;
+      checkpointMarks.length = 0;
     },
     newSession() {
       session = Session.create(home, opts.cwd);
@@ -1736,12 +2053,36 @@ function createRuntime(opts) {
       agent.totalUsage = { inputTokens: 0, outputTokens: 0 };
       todos.set([]);
       checkpoints.clear();
+      turnMarks.length = 0;
+      checkpointMarks.length = 0;
       startedAt = /* @__PURE__ */ new Date();
     },
     rebuildSystemPrompt() {
-      agent.setSystemPrompt(buildSystemPrompt({ cwd: opts.cwd, home, model: modelRef, skills }));
+      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;
     },
@@ -1749,6 +2090,7 @@ function createRuntime(opts) {
       const nextProvider = makeProvider(ref);
       modelRef = ref;
       agent.provider = nextProvider;
+      agent.setContextWindow(contextWindowFor(ref, env));
       agent.setSystemPrompt(buildSystemPrompt({ cwd: opts.cwd, home, model: modelRef, skills }));
     },
     setReasoning(level) {
@@ -1759,7 +2101,7 @@ function createRuntime(opts) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.4.0-beta.36" : "0.0.0-dev";
+var VERSION = true ? "0.4.0-beta.37" : "0.0.0-dev";
 
 // src/cli.ts
 function chooseLanguage(argv) {
@@ -1781,20 +2123,21 @@ async function main() {
     console.log(helpText());
     return 0;
   }
-  const cwd = process.cwd();
+  let cwd = process.cwd();
+  if (args.worktree) cwd = (await resolveWorktree(cwd, args.worktree)).path;
   if (args.command === "login") return runLogin(args.loginProvider ?? "bc-cloud", cwd);
   if (args.command === "mcp") {
-    const { runMcpCommand } = await import("./mcpCli-THHBIX7I.js");
-    const { readSecret } = await import("./login-LKAO5PVR.js");
+    const { runMcpCommand } = await import("./mcpCli-5ZSAMBJS.js");
+    const { readSecret } = await import("./login-MHVCON5R.js");
     return runMcpCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s), readSecret });
   }
   if (args.command === "provider") {
-    const { runProviderCommand } = await import("./providerCli-WJXJW3W2.js");
-    const { readSecret } = await import("./login-LKAO5PVR.js");
+    const { runProviderCommand } = await import("./providerCli-Z3TZ5XSZ.js");
+    const { readSecret } = await import("./login-MHVCON5R.js");
     return runProviderCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s), readSecret });
   }
   if (args.command === "connect" || args.command === "disconnect" || args.command === "integrations") {
-    const { runIntegrationCommand } = await import("./integrationCli-JWLY6E7E.js");
+    const { runIntegrationCommand } = await import("./integrationCli-ZTZTQD2I.js");
     return runIntegrationCommand(args, {
       env: process.env,
       cwd,
@@ -1817,20 +2160,20 @@ async function main() {
   }
   if (args.print) {
     if (!args.prompt) throw new ConfigError(t('-p mode needs a task, e.g. bccli -p "explain this repo"'));
-    const { serversToStart } = await import("./config-53MC3AH2.js");
+    const { serversToStart } = await import("./config-JRO5EOKZ.js");
     const plan = serversToStart(rt.home, cwd);
     for (const s of plan.needTrust) {
       console.error(t('Project MCP server "{name}" skipped (not approved yet; run interactive bccli once to approve it).', { name: s.name }));
     }
     await rt.startMcp(plan.start);
     try {
-      return await runPrint(rt, args.prompt, void 0, { allowAll: args.allowAll });
+      return await runPrint(rt, args.prompt, void 0, { allowAll: args.allowAll, outputFormat: args.outputFormat });
     } finally {
       await rt.mcp.stop();
     }
   }
   if (!process.stdin.isTTY) throw new ConfigError(t('Interactive mode needs a terminal. For scripts/CI use: bccli -p "task"'));
-  const { startInteractive } = await import("./ui-I5BTZATT.js");
+  const { startInteractive } = await import("./ui-YLIKFLGN.js");
   return startInteractive(rt, { initialPrompt: args.prompt, resume: args.resume, version: VERSION });
 }
 main().then(