@botconnector/bccli 0.4.1 → 0.4.3

package/dist/{chunk-PZRKU4UM.js → chunk-QNUJHKEL.js}

@@ -5,66 +5,71 @@ import {
   pruneOldToolOutputs,
   splitKeepRecent,
   trimToFit
-} from "./chunk-QZKLZELZ.js";
+} 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-BGXNR74O.js";
+} from "./chunk-4W5SKQDC.js";
 import {
   createWebSearchTool,
   fetchTool
-} from "./chunk-45SDLMTV.js";
+} from "./chunk-JXM6REER.js";
 import {
   defineTool
 } from "./chunk-PSO7R5AD.js";
 import {
   Permissions
-} from "./chunk-MHIYLXJC.js";
+} from "./chunk-WFZKJY3R.js";
 import {
   addProviderKey
-} from "./chunk-GN4W3T6E.js";
+} from "./chunk-GWVLPN4B.js";
 import {
   listAllModels
-} from "./chunk-75BECX4F.js";
+} from "./chunk-7I2ZGPUS.js";
 import {
   providerName
-} from "./chunk-JHPGOAXU.js";
+} from "./chunk-HQW4BROS.js";
 import {
   FileOAuthProvider,
   hasStoredTokens
-} from "./chunk-MFHCQQEN.js";
+} from "./chunk-3I5BW3ZT.js";
 import {
   Session
-} from "./chunk-BC7UXFE4.js";
+} from "./chunk-6AUROP2E.js";
 import {
   completionAssistantMessage,
   createProvider,
   hasPendingProgrammaticReplay,
-  imageUserMessage
-} from "./chunk-WNACAUDK.js";
+  imageUserMessage,
+  withFallbackProvider
+} from "./chunk-XTOATEI6.js";
 import {
   expandEnvVars
-} from "./chunk-24JN75FZ.js";
+} from "./chunk-6M55UPES.js";
 import {
   ConfigError,
   bccliHome,
   loadConfig,
   resolveModel
-} from "./chunk-FLQPE4S5.js";
+} from "./chunk-RX4UQX43.js";
 import {
   t
-} from "./chunk-UZWJQF67.js";
+} from "./chunk-3WHI4LN3.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;
@@ -164,47 +169,108 @@ function formatDiff(lines) {
   return lines.map((l) => `${String(l.line).padStart(5)} ${mark[l.kind]} ${l.text}`).join("\n");
 }
 
-// src/tools/paths.ts
-import { isAbsolute, resolve } from "path";
-function resolvePath(cwd, path) {
-  return isAbsolute(path) ? path : resolve(cwd, path);
-}
-function errorCode(error) {
-  return error.code ?? error.message;
-}
-
 // src/tools/edit.ts
-var schema = z.object({
-  path: z.string().describe("File path, relative to the project or absolute"),
+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 applyEdit(content, input) {
+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 ${input.path}. Add more context to make it unique, or use replace_all.`,
+        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);
   }
-  return { output: `old_string not found in ${input.path}. Re-read the file.`, isError: true };
+  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",
@@ -215,6 +281,9 @@ var editTool = defineTool({
   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");
@@ -235,6 +304,9 @@ var editTool = defineTool({
     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");
@@ -245,25 +317,28 @@ var editTool = defineTool({
     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((resolve2, reject) => {
-    const onAbort = () => resolve2(ABORTED);
+  return new Promise((resolve, reject) => {
+    const onAbort = () => resolve(ABORTED);
     signal.addEventListener("abort", onAbort, { once: true });
     promise.then(
       (value) => {
         signal.removeEventListener("abort", onAbort);
-        resolve2(value);
+        resolve(value);
       },
       (error) => {
         signal.removeEventListener("abort", onAbort);
@@ -297,19 +372,30 @@ var globTool = defineTool({
     path: z2.string().optional().describe("Base directory, default project root")
   }),
   kind: "read",
-  target: (input) => input.pattern,
+  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) }),
+      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 };
-    files.sort();
+    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 = [];
@@ -330,75 +416,141 @@ var globTool = defineTool({
 
 // 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 regex = new RegExp(pattern, opts.ignoreCase ? "i" : "");
+  const source = opts.literal ? escapeRegExp(pattern) : pattern;
+  const regex = new RegExp(source, opts.ignoreCase ? "i" : "");
+  const single = isSingleFile(opts.root);
   const files = [];
-  const finished = await collectUntilAbort(
-    nativeGlob2(opts.glob ?? "**/*", { cwd: opts.root, exclude: ignorePatterns(opts.root) }),
-    opts.signal,
-    (file) => files.push(normalizeGlobPath(file))
-  );
+  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 = [];
-  if (!finished) return out;
   for (const file of files.sort()) {
     if (opts.signal?.aborted) break;
     let text;
     try {
-      const buffer = await readFile2(resolvePath(opts.root, file));
+      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])) out.push(`${file}:${i + 1}:${lines[i].slice(0, 300)}`);
+      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 args = ["--line-number", "--no-heading", "--color", "never", "--max-columns", "300", "-e", pattern];
+  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) args.push("-g", opts.glob);
-  args.push(".");
-  return new Promise((resolve2) => {
-    execFile("rg", args, { cwd: opts.root, maxBuffer: 10 * 1024 * 1024, signal: opts.signal }, (error, stdout) => {
-      if (opts.signal?.aborted) return resolve2([]);
+  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 resolve2(void 0);
-      if (error && error.code !== 1) return resolve2(void 0);
-      resolve2(stdout.split("\n").filter(Boolean).map((l) => l.replace(/^\.\//, "")).slice(0, MAX_MATCHES));
+      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. Respects .gitignore. Returns path:line:text (max 200).",
+  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"),
-    path: z3.string().optional().describe("Directory to search, default project root"),
+    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()
+    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.pattern,
+  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 ?? "."), glob: input.glob, ignoreCase: input.ignore_case, signal: ctx.signal };
-    try {
-      new RegExp(input.pattern);
-    } catch (error) {
-      return { output: `Invalid regex: ${error.message}`, isError: true };
+    const 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 };
@@ -420,6 +572,7 @@ var grepTool = defineTool({
 });
 
 // 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;
@@ -503,6 +656,16 @@ function createReadTool(options = {}) {
     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);
@@ -511,13 +674,13 @@ function createReadTool(options = {}) {
       }
       const mediaType = vision ? imageMediaType(buffer) : void 0;
       if (mediaType) {
-        ctx.readFiles.add(abs);
+        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 };
       }
-      ctx.readFiles.add(abs);
+      recordFileMtime(ctx.readFiles, abs);
       return readTextResult(input, buffer);
     }
   });
@@ -527,7 +690,7 @@ 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 { dirname as dirname2 } from "path";
 import { z as z5 } from "zod";
 var writeTool = defineTool({
   name: "write",
@@ -554,12 +717,12 @@ var writeTool = defineTool({
     }
     try {
       await ctx.checkpoint?.(abs);
-      await mkdir(dirname(abs), { recursive: true });
+      await mkdir(dirname2(abs), { recursive: true });
       await writeFile2(abs, input.content);
     } catch (error) {
       return { output: `Failed to write ${input.path}: ${errorCode(error)}`, isError: true };
     }
-    ctx.readFiles.add(abs);
+    recordFileMtime(ctx.readFiles, abs);
     const lines = input.content.split("\n").length;
     return { output: `Wrote ${input.path} (${lines} lines).`, display: t("{lines} lines written", { lines }) };
   }
@@ -683,6 +846,7 @@ var Agent = class {
     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";
   }
@@ -706,6 +870,7 @@ var Agent = class {
   maxSteps;
   // One window for every model; resolved from contextWindowFor() (catalog + env override).
   contextWindow;
+  budgetModel;
   systemPrompt;
   setSystemPrompt(text) {
     this.systemPrompt = text;
@@ -713,6 +878,15 @@ var Agent = class {
   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);
@@ -913,7 +1087,7 @@ ${t("This model may not support tool calling. Try another model with /model.")}`
   }
   /** Current cap status; undefined means the budget is not exhausted. */
   overBudget() {
-    return budgetStatus(this.totalUsage, this.opts.usageCap, this.opts.budgetModel ?? "");
+    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) {
@@ -1033,7 +1207,7 @@ ${t("This model may not support tool calling. Try another model with /model.")}`
 };
 
 // src/checkpoints.ts
-import { existsSync as existsSync2, statSync } from "fs";
+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;
@@ -1060,8 +1234,8 @@ var CheckpointStore = class {
   history = [];
   current;
   pendingRedo;
+  offset = 0;
   beginTurn() {
-    if (this.current?.size === 0) return;
     this.current = /* @__PURE__ */ new Map();
     this.history.push(this.current);
     this.pendingRedo = void 0;
@@ -1072,16 +1246,19 @@ var CheckpointStore = class {
     const turn = this.current;
     if (turn.has(path)) return;
     if (!existsSync2(path)) turn.set(path, null);
-    else if (statSync(path).size > MAX_BYTES) turn.set(path, "skipped");
+    else 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();
+    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.history.length;
+    return this.offset + this.history.length;
   }
   async undo() {
     while (this.history.length && !this.history.at(-1)?.size) this.history.pop();
@@ -1101,7 +1278,7 @@ var CheckpointStore = class {
    * 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 target = Math.max(0, Math.min(keep - this.offset, this.history.length));
     const result = emptyResult();
     const redo = /* @__PURE__ */ new Map();
     let applied = false;
@@ -1126,8 +1303,11 @@ var CheckpointStore = class {
     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. */
@@ -1140,7 +1320,7 @@ var CheckpointStore = class {
       }
       try {
         if (!existsSync2(path)) into.set(path, null);
-        else if (statSync(path).size > MAX_BYTES) into.set(path, "skipped");
+        else if (statSync4(path).size > MAX_BYTES) into.set(path, "skipped");
         else into.set(path, await readFile5(path));
       } catch {
         into.set(path, "skipped");
@@ -1151,6 +1331,7 @@ var CheckpointStore = class {
     this.history.length = 0;
     this.current = void 0;
     this.pendingRedo = void 0;
+    this.offset = 0;
   }
 };
 
@@ -1176,7 +1357,28 @@ import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { z as z7 } from "zod";
-var MCP_OUTPUT_MAX_CHARS = 32e3;
+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",
@@ -1305,11 +1507,13 @@ var McpManager = class {
       async run(input, ctx) {
         try {
           const result = await client.callTool({ name: tool.name, arguments: input }, void 0, { signal: ctx.signal });
-          const output = (result.content ?? []).map((c) => c.type === "text" ? c.text ?? "" : `[${c.type}]`).join("\n") || "(empty)";
+          const formatted = formatMcpContent(result.content);
+          const output = formatted.output;
           return {
-            output: output.length > MCP_OUTPUT_MAX_CHARS ? `${output.slice(0, MCP_OUTPUT_MAX_CHARS)}
-\u2026 [truncated at ${MCP_OUTPUT_MAX_CHARS} characters; narrow the MCP request if possible]` : output,
-            isError: !!result.isError
+            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 };
@@ -1388,6 +1592,7 @@ 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(
@@ -1407,7 +1612,8 @@ ${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")
+      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}`,
@@ -1434,6 +1640,7 @@ ${list}`,
       } 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,
@@ -1443,6 +1650,7 @@ ${list}`,
 # 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,
@@ -1463,12 +1671,29 @@ ${def.prompt}`,
       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 };
-      const last = [...child.messages].reverse().find((m) => m.role === "assistant" && m.content);
+      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" ? `
 
@@ -1514,7 +1739,7 @@ function createTodoTool(store) {
 
 // src/tools/memory.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { join } from "path";
+import { join as join2 } from "path";
 import { z as z12 } from "zod";
 function createSaveMemoryTool(opts) {
   return defineTool({
@@ -1527,11 +1752,11 @@ function createSaveMemoryTool(opts) {
     kind: "edit",
     // The target is what the prompt shows and what the permission model judges: the
     // global store really lives outside the project, so it must not look like one.
-    target: (input) => input.scope === "global" ? join(opts.home, "BCCLI.md") : "AGENTS.md",
+    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" ? join(opts.home, "BCCLI.md") : join(ctx.cwd, "AGENTS.md");
+      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}`)) {
@@ -1549,18 +1774,21 @@ function createSaveMemoryTool(opts) {
 import { z as z13 } from "zod";
 
 // src/repomap.ts
-import { readdirSync, readFileSync as readFileSync3 } from "fs";
-import { extname, join as join2, relative, sep } from "path";
+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"
 ]);
@@ -1586,21 +1814,22 @@ var CODE_EXTS = /* @__PURE__ */ new Set([
   ".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+)?(?:abstract\s+)?(?:async\s+)?(?:function|class|interface|type|enum)\s+([A-Za-z0-9_$]+)/,
+    /^\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*class\s+(\w+)/],
+  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", ".rb"].includes(ext)) return FAMILY.ts;
-  if (ext === ".py" || ext === ".sh" || ext === ".ps1") return FAMILY.py;
+  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;
@@ -1620,16 +1849,16 @@ function extractSymbols(text, ext) {
   return out;
 }
 function walk(dir, root, files) {
-  if (files.length >= MAX_FILES) return;
+  if (files.length >= MAX_SCAN_FILES) return;
   let entries;
   try {
-    entries = readdirSync(dir, { withFileTypes: true });
+    entries = readdirSync2(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-    if (files.length >= MAX_FILES) return;
-    const full = join2(dir, e.name);
+    if (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);
@@ -1640,11 +1869,12 @@ function walk(dir, root, files) {
 }
 function buildRepoMapSync(cwd, opts = {}) {
   const maxTokens = opts.maxTokens ?? 2048;
-  const files = [];
-  walk(cwd, cwd, files);
-  files.sort(
+  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;
@@ -1684,13 +1914,50 @@ function createRepoMapTool() {
 }
 
 // src/tools/diagnostics.ts
-import { extname as extname2 } from "path";
+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 { pathToFileURL } from "url";
+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
@@ -1722,89 +1989,281 @@ function createLspParser(onMessage) {
     }
   };
 }
-function getDiagnostics(opts) {
-  return new Promise((resolve2) => {
-    const child = spawn(opts.server.command, opts.server.args ?? [], { cwd: opts.cwd, stdio: ["pipe", "pipe", "ignore"] });
-    const uri = pathToFileURL(opts.file).href;
-    let settled = false;
-    let nextId = 2;
-    const send = (msg) => {
-      try {
-        child.stdin.write(encodeLsp(msg));
-      } catch {
-      }
-    };
-    const finish = (diags) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      send({ jsonrpc: "2.0", id: nextId++, method: "shutdown" });
-      send({ jsonrpc: "2.0", method: "exit" });
-      const killer = setTimeout(() => {
-        try {
-          child.kill();
-        } catch {
+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();
         }
-      }, 500);
-      killer.unref?.();
-      resolve2(diags);
-    };
-    const timer = setTimeout(() => finish([]), opts.timeoutMs ?? 8e3);
-    const parser = createLspParser((msg) => {
-      if (msg.id === 1 && msg.result) {
-        send({ jsonrpc: "2.0", method: "initialized", params: {} });
-        let text = "";
-        try {
-          text = readFileSync4(opts.file, "utf8");
-        } catch {
+      };
+      const parser = createLspParser((msg) => {
+        if (msg.id === 1 && msg.result !== void 0) {
+          send({ jsonrpc: "2.0", method: "initialized", params: {} });
+          settleInit();
+          return;
         }
-        send({
-          jsonrpc: "2.0",
-          method: "textDocument/didOpen",
-          params: { textDocument: { uri, languageId: "plaintext", version: 1, text } }
-        });
-      }
-      if (msg.method === "textDocument/publishDiagnostics" && msg.params?.uri === uri) {
-        finish(
-          (msg.params.diagnostics ?? []).map((d) => ({
+        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 }
+      });
     });
-    child.stdout?.on("data", (c) => parser.push(c));
-    child.on("error", () => finish([]));
-    child.on("close", () => finish([]));
-    send({
-      jsonrpc: "2.0",
-      id: 1,
-      method: "initialize",
-      params: { processId: process.pid, capabilities: {}, rootUri: pathToFileURL(opts.cwd).href }
+    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)") });
+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: 'Run the configured LSP server(s) on one file and return its diagnostics (errors/warnings). Configure servers under "lsp.servers" in ~/.bccli/config.json, e.g. { "extensions": [".ts"], "command": "typescript-language-server", "args": ["--stdio"] }.',
+    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 = extname2(file).toLowerCase();
+      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 diags = await getDiagnostics({ server, cwd: ctx.cwd, file, timeoutMs: 15e3 });
+      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) };
@@ -1815,7 +2274,7 @@ function createDiagnosticsTool(servers) {
 // src/plugins.ts
 import { existsSync as existsSync4 } from "fs";
 import { createRequire } from "module";
-import { isAbsolute as isAbsolute2, join as join3 } from "path";
+import { isAbsolute, join as join4 } from "path";
 import { z as z15 } from "zod";
 var require_ = createRequire(import.meta.url);
 function pluginLog(message) {
@@ -1840,7 +2299,7 @@ function loadPlugins(specs, opts) {
   for (const spec of specs) {
     let file;
     try {
-      file = isAbsolute2(spec) ? spec : spec.startsWith(".") ? join3(opts.home, spec) : require_.resolve(spec);
+      file = isAbsolute(spec) ? spec : spec.startsWith(".") ? join4(opts.home, spec) : require_.resolve(spec);
     } catch {
       throw new ConfigError(t("Plugin not found: {spec}", { spec }));
     }
@@ -1917,7 +2376,7 @@ function createRuntime(opts) {
   let config = loadConfig(opts.cwd, env);
   let modelRef = opts.args.model ?? config.model;
   let reasoning = opts.args.reasoning ?? config.reasoning;
-  const makeProvider = (ref) => {
+  const makeSingleProvider = (ref) => {
     const resolved = resolveModel(config, ref, env);
     return opts.provider ?? createProvider({
       baseURL: resolved.baseURL,
@@ -1929,6 +2388,25 @@ function createRuntime(opts) {
       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)];
@@ -1950,6 +2428,10 @@ function createRuntime(opts) {
     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;
@@ -1993,7 +2475,7 @@ function createRuntime(opts) {
     // Subagents get whatever the main agent has right now (incl. MCP tools), minus task itself.
     baseTools: () => agent.tools.filter((t2) => t2.name !== "task"),
     permissions,
-    provider: () => agent.provider,
+    provider: () => opts.provider ? agent.provider : makeProvider(modelRef),
     providerFor: makeProvider,
     systemPrompt: (childModelRef) => systemFor(childModelRef ?? modelRef),
     cwd: opts.cwd,
@@ -2079,6 +2561,20 @@ function createRuntime(opts) {
       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;
@@ -2127,6 +2623,7 @@ function createRuntime(opts) {
       const nextProvider = makeProvider(ref);
       modelRef = ref;
       agent.provider = nextProvider;
+      agent.setBudgetModel(ref);
       agent.setContextWindow(contextWindowFor(ref, env));
       agent.setSystemPrompt(systemFor(modelRef));
     },