@botconnector/bccli 0.4.0 → 0.4.2

package/dist/sdk.js

@@ -500,7 +500,8 @@ Opsi:
   "gh is not available ({error}); install GitHub CLI first": "gh tidak tersedia ({error}); pasang GitHub CLI dulu",
   "gh pr checkout {n} failed (exit {code})": "gh pr checkout {n} gagal (exit {code})",
   "checked out PR #{n}": "checkout PR #{n} selesai",
-  "--allow-all: the PR task runs every tool without asking": "--allow-all: tugas PR menjalankan semua alat tanpa bertanya"
+  "--allow-all: the PR task runs every tool without asking": "--allow-all: tugas PR menjalankan semua alat tanpa bertanya",
+  "view or change configuration settings": "lihat atau ubah pengaturan konfigurasi"
 };
 
 // src/i18n.ts
@@ -689,8 +690,11 @@ function loadConfig(cwd, env = process.env) {
   const project = readJsonConfig(join(cwd, ".bccli", "config.json"));
   const known = { ...DEFAULT_CONFIG.providers, ...global.providers };
   const fromProject = untrustedProviders(project, known);
+  const rawFallbacks = project.fallbackModels ?? global.fallbackModels;
+  const fallbackModels = Array.isArray(rawFallbacks) ? rawFallbacks.filter((m) => typeof m === "string" && m.includes("/")) : void 0;
   return {
     model: project.model ?? global.model ?? DEFAULT_CONFIG.model,
+    ...fallbackModels?.length ? { fallbackModels } : {},
     permissionMode: global.permissionMode ?? DEFAULT_CONFIG.permissionMode,
     reasoning: global.reasoning ?? DEFAULT_CONFIG.reasoning,
     thinkingVisible: global.thinkingVisible === true,
@@ -715,21 +719,46 @@ function loadConfig(cwd, env = process.env) {
     allow: [...global.allow ?? []]
   };
 }
+function writeFileAtomic(path, data, mode) {
+  const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+  try {
+    writeFileSync(tmp, data, mode === void 0 ? void 0 : { mode });
+    renameSync(tmp, path);
+    if (mode !== void 0) chmodSync(path, mode);
+  } catch (error) {
+    try {
+      rmSync(tmp, { force: true });
+    } catch {
+    }
+    throw error;
+  }
+}
+function quarantineCorruptFile(path, error) {
+  const stamp = Date.now();
+  let dest = `${path}.corrupt-${stamp}`;
+  for (let n = 1; existsSync(dest); n++) dest = `${path}.corrupt-${stamp}-${n}`;
+  try {
+    renameSync(path, dest);
+  } catch {
+    return void 0;
+  }
+  console.error(`${path} is not valid JSON (${error.message}); moved it to ${dest} instead of overwriting it.`);
+  return dest;
+}
 function readCredentials(env = process.env) {
   const path = join(bccliHome(env), "credentials");
   if (!existsSync(path)) return {};
   try {
     return JSON.parse(readFileSync(path, "utf8"));
-  } catch {
+  } catch (error) {
+    quarantineCorruptFile(path, error);
     return {};
   }
 }
 function saveCredential(providerId, key, env = process.env) {
   const home = bccliHome(env);
   mkdirSync(home, { recursive: true });
-  const path = join(home, "credentials");
-  writeFileSync(path, JSON.stringify({ ...readCredentials(env), [providerId]: key }, null, 2), { mode: 384 });
-  chmodSync(path, 384);
+  writeFileAtomic(join(home, "credentials"), JSON.stringify({ ...readCredentials(env), [providerId]: key }, null, 2), 384);
 }
 function resolveModel(config, modelRef, env = process.env) {
   const slash = modelRef.indexOf("/");
@@ -749,7 +778,7 @@ function resolveModel(config, modelRef, env = process.env) {
 }
 
 // src/permissions.ts
-import { isAbsolute, relative, resolve, sep } from "path";
+import { isAbsolute, relative, resolve } from "path";
 var MODE_ORDER = ["default", "acceptEdits", "plan", "allowAll"];
 var ALWAYS_ASK_COMMANDS = /* @__PURE__ */ new Set(["sudo", "sh", "bash", "zsh", "su"]);
 function isAlwaysAsk(segment) {
@@ -765,14 +794,51 @@ function isAlwaysAsk(segment) {
   }
   return false;
 }
+var RUNNER_COMMANDS = /* @__PURE__ */ new Set([
+  "npm",
+  "npx",
+  "pnpm",
+  "pnpx",
+  "yarn",
+  "bun",
+  "bunx",
+  "deno",
+  "node",
+  "tsx",
+  "ts-node",
+  "python",
+  "python3",
+  "py",
+  "uv",
+  "uvx",
+  "pip",
+  "pip3",
+  "pipx",
+  "pytest",
+  "make",
+  "cargo",
+  "go",
+  "dotnet",
+  "java",
+  "ruby",
+  "bundle",
+  "rake",
+  "gradle",
+  "mvn",
+  "php",
+  "composer"
+]);
 function commandKey(segment) {
   const words2 = segment.trim().split(/\s+/);
+  if (RUNNER_COMMANDS.has(words2[0] ?? "") && words2[2] && !words2[2].startsWith("-")) return words2.slice(0, 3).join(" ");
   return words2[1] ? `${words2[0]} ${words2[1]}` : words2[0];
 }
 function requiresSensitiveToolApproval(req) {
   const target = req.target.trim();
   if (req.kind === "read" || req.kind === "edit") {
-    return /(?:^|[/\\])(?:\.env(?:\..*)?|\.ssh|\.aws|\.config\/gcloud|secrets?|credentials?)(?:[/\\]|$)/i.test(target) || /(?:id_rsa|id_ed25519|\.pem|\.p12|\.key)$/i.test(target);
+    return /(?:^|[\s/\\])(?:\.env(?:\.[^\s/\\]+)?|\.ssh|\.aws|\.config[/\\]gcloud|\.npmrc|\.netrc|\.git-credentials|(?:secrets?|credentials?)(?:\.[a-z0-9_-]+)?)(?:[\s/\\]|$)/i.test(
+      target
+    ) || /(?:id_rsa|id_ed25519|\.pem|\.p12|\.key)(?:\s|$)/i.test(target);
   }
   if (req.kind === "bash") {
     return /\b(?:rm\s+-[a-z]*r[a-z]*f[a-z]*\s|rm\s+-[a-z]*f[a-z]*r[a-z]*\s|mkfs(?:\.|\s)|wipefs\b|shred\s|git\s+push\s+(?:--force|-f)\b|docker\s+(?:system\s+prune|volume\s+rm)|kubectl\s+delete\b|drop\s+(?:database|table)|npm\s+publish\b)/i.test(target) || /\b(?:deploy-service\.sh|aws\s+secretsmanager|cat\s+[^;&|]*\.env\b)/i.test(target);
@@ -797,7 +863,8 @@ var Permissions = class {
   editInProject(target) {
     const rel = relative(this.cwd, resolve(this.cwd, target));
     if (!rel || rel.startsWith("..") || isAbsolute(rel)) return false;
-    return !rel.split(sep).includes(".git") && !rel.split("/").includes(".git");
+    const parts = rel.split(/[/\\]/).map((p) => p.toLowerCase());
+    return !parts.includes(".git");
   }
   /** Rules that "[a] allow for this session" would add; undefined when it must always be asked. */
   rulesFor(req) {
@@ -815,7 +882,7 @@ var Permissions = class {
       if (/`|\$\(|[<>]|^\s*[({]/.test(req.target)) return void 0;
       const segments = req.target.split(/&&|\|\||[;&|\n]/).map((s) => s.trim()).filter(Boolean);
       if (!segments.length) return void 0;
-      if (segments.some(isAlwaysAsk)) return void 0;
+      if (segments.some((s) => /^[({]/.test(s) || isAlwaysAsk(s))) return void 0;
       return [...new Set(segments.map((s) => `bash(${commandKey(s)})`))];
     }
     if (req.kind === "mcp") return [`mcp(${req.tool})`];
@@ -893,9 +960,12 @@ var LOOPBACK_BIND = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "::1"]);
 
 // src/args.ts
 function parseCliArgs(argv) {
-  const expanded = argv.map(
-    (a, i) => a === "--models" && (i + 1 >= argv.length || argv[i + 1].startsWith("-")) ? "--models=all" : a
-  );
+  const expanded = argv.map((a, i) => {
+    const nextIsFlagOrEnd = i + 1 >= argv.length || argv[i + 1].startsWith("-");
+    if (a === "--models" && nextIsFlagOrEnd) return "--models=all";
+    if (a === "--project" && nextIsFlagOrEnd) return "--project=";
+    return a;
+  });
   const { values, positionals } = parseArgs({
     args: expanded,
     allowPositionals: true,
@@ -927,7 +997,8 @@ function parseCliArgs(argv) {
       tools: { type: "string" },
       models: { type: "string" },
       project: { type: "string" },
-      repo: { type: "string" }
+      repo: { type: "string" },
+      "fallback-model": { type: "string" }
     }
   });
   const reasoning = values.reasoning;
@@ -1001,7 +1072,8 @@ function parseCliArgs(argv) {
     tools,
     models,
     project: values.project,
-    repo: values.repo
+    repo: values.repo,
+    fallbackModel: values["fallback-model"]
   };
 }
 
@@ -1093,14 +1165,14 @@ function detectRepetition(text) {
   return -1;
 }
 function sleep(ms, signal) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const onAbort = () => {
       clearTimeout(timer);
       reject(signal?.reason);
     };
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve4();
+      resolve5();
     }, ms);
     signal?.addEventListener("abort", onAbort, { once: true });
   });
@@ -1170,7 +1242,7 @@ async function readStream(res, onText, onThinking) {
       }
       current2 = target;
       if (tc.id) target.id = tc.id;
-      if (tc.function?.name && !target.name) target.name = tc.function.name;
+      if (tc.function?.name && target.name !== tc.function.name) target.name += tc.function.name;
       if (tc.function?.arguments) target.arguments += tc.function.arguments;
     }
   };
@@ -1377,7 +1449,16 @@ function responsesFinishReason(items, toolCallCount, incompleteReason) {
 function hasPendingProgrammaticReplay(messages) {
   let pending = false;
   for (const message of messages) {
+    if (message.role === "user" && typeof message.content === "string") {
+      pending = false;
+      continue;
+    }
+    if (message.role === "tool" && message.content === "Cancelled by the user.") {
+      pending = false;
+      continue;
+    }
     if (message.role !== "assistant") continue;
+    if (message.content) pending = false;
     for (const item of message.responses_output_items ?? []) {
       if (item.type === "program") pending = true;
       else if (item.type === "message" && pending) pending = false;
@@ -1451,7 +1532,7 @@ async function readResponsesStream(res, onText, onThinking) {
         calls.set(index, {
           id: String(event.item.call_id || current2?.id || event.item.id || `call_${index}`),
           name: String(event.item.name || current2?.name || ""),
-          arguments: String(event.item.arguments ?? current2?.arguments ?? ""),
+          arguments: String(event.item.arguments || current2?.arguments || ""),
           ...programCaller(event.item) ?? current2?.caller ? { caller: programCaller(event.item) ?? current2?.caller } : {}
         });
       }
@@ -1687,7 +1768,7 @@ async function readResponsesWebSocketTurn(events, ws, onText, onThinking, signal
           calls.set(index, {
             id: String(event.item.call_id || current2?.id || event.item.id || `call_${index}`),
             name: String(event.item.name || current2?.name || ""),
-            arguments: String(event.item.arguments ?? current2?.arguments ?? ""),
+            arguments: String(event.item.arguments || current2?.arguments || ""),
             ...programCaller(event.item) ?? current2?.caller ? { caller: programCaller(event.item) ?? current2?.caller } : {}
           });
         }
@@ -1748,7 +1829,7 @@ function createProvider(options) {
   const isBotConnectorCloud = /^https:\/\/api\.botconnector\.id\/v1\/?$/.test(baseURL) && apiKey?.startsWith("bc_live_");
   if (isBotConnectorCloud) {
     headers["x-botconnector-client"] = "bccli";
-    headers["x-botconnector-client-version"] = "0.4.0";
+    headers["x-botconnector-client-version"] = "0.4.2";
   }
   const useNativeResponses = isBotConnectorCloud && providerId === "bc-cloud" && model === "gpt-6-luna";
   const useResponsesWebSocket = useNativeResponses && Boolean(apiKey) && (fetchOverride === void 0 || responsesWebSocketFactory !== void 0);
@@ -1779,7 +1860,7 @@ function createProvider(options) {
         baseURL: baseURL.replace(/\/+$/, ""),
         defaultHeaders: {
           "x-botconnector-client": "bccli",
-          "x-botconnector-client-version": "0.4.0"
+          "x-botconnector-client-version": "0.4.2"
         }
       });
       lunaWs = responsesWebSocketFactory ? responsesWebSocketFactory(client) : new ResponsesWS(client, { reconnect: null });
@@ -1842,8 +1923,13 @@ function createProvider(options) {
       } catch (error) {
         const err = error instanceof ProviderError ? error : new ProviderError(error.message);
         const lostPrevious = err.code === "previous_response_not_found";
+        const handshakeStatus = /unexpected server response:\s*(\d{3})\b/i.exec(err.message);
+        const handshakeRejected = Boolean(handshakeStatus && Number(handshakeStatus[1]) >= 400);
         const connectionLost = /websocket|connection closed|socket|network/i.test(err.message) || err.code === "websocket_connection_limit_reached";
         resetLunaWebSocket();
+        if (!emittedText && !signal?.aborted && handshakeRejected) {
+          throw new ProviderError(err.message, Number(handshakeStatus?.[1]), "bc_ws_http_fallback");
+        }
         if (attempt === 0 && !emittedText && !signal?.aborted && (plan.incremental || lostPrevious || connectionLost)) {
           continue;
         }
@@ -1857,8 +1943,13 @@ function createProvider(options) {
   }
   async function post(path, body, signal) {
     let lastError;
+    let retryAfterWaitMs;
     for (let attempt = 0; attempt < 4; attempt++) {
-      if (attempt > 0) await sleep(retryDelayMs * 2 ** (attempt - 1), signal);
+      if (attempt > 0) {
+        const delay = retryAfterWaitMs ?? retryDelayMs * 2 ** (attempt - 1);
+        retryAfterWaitMs = void 0;
+        await sleep(delay, signal);
+      }
       let res;
       try {
         res = await doFetch(`${baseURL}${path}`, { method: "POST", headers, body: JSON.stringify(body), signal });
@@ -1868,9 +1959,15 @@ function createProvider(options) {
         continue;
       }
       if (res.ok) return res;
+      const retryHeader = res.headers.get("retry-after");
+      if (retryHeader) {
+        const secs = Number(retryHeader);
+        if (Number.isFinite(secs) && secs > 0 && secs <= 30) retryAfterWaitMs = Math.ceil(secs * 1e3);
+      }
       const text = await res.text().catch(() => "");
       lastError = new ProviderError(t("{status} from {url}: {message}", { status: res.status, url: baseURL, message: errorMessage(text) }), res.status);
-      if (!retryable(res.status)) throw lastError;
+      const deterministicQuota429 = res.status === 429 && /"code"\s*:\s*"(?:luna_monthly_quota_exhausted|plan_allowance_exhausted)"/i.test(text);
+      if (!retryable(res.status) || deterministicQuota429) throw lastError;
     }
     throw lastError ?? new ProviderError(t("Request failed"));
   }
@@ -1929,6 +2026,43 @@ function createProvider(options) {
     }
   };
 }
+function withFallbackProvider(primary, fallbacks) {
+  return {
+    async chat(req) {
+      let emitted = false;
+      const wrappedReq = {
+        ...req,
+        onText: req.onText ? (delta) => {
+          emitted = true;
+          req.onText?.(delta);
+        } : () => {
+          emitted = true;
+        }
+      };
+      try {
+        return await primary.chat(wrappedReq);
+      } catch (primaryError) {
+        if (emitted || req.signal?.aborted) throw primaryError;
+        const status = primaryError instanceof ProviderError ? primaryError.status : void 0;
+        const canFallback = status === void 0 || status === 429 || status === 408 || status >= 500;
+        if (!canFallback) throw primaryError;
+        const chain = fallbacks();
+        if (!chain.length) throw primaryError;
+        let lastError = primaryError;
+        for (const fb of chain) {
+          if (req.signal?.aborted) throw lastError;
+          try {
+            return await fb.chat(req);
+          } catch (fbError) {
+            lastError = fbError;
+          }
+        }
+        throw lastError;
+      }
+    },
+    listModels: () => primary.listModels()
+  };
+}
 
 // src/textToolCalls.ts
 var PAIR = /(?:<arg_key>\s*|`)?([A-Za-z_]\w*)(?:\s*<\/arg_key>)?`?\s*(?:=\s*`|<arg_value>)([\s\S]*?)<\/arg_value>/g;
@@ -2048,7 +2182,7 @@ function runOne(command, event, payload, opts) {
     ...payload.input !== void 0 ? { BCCLI_HOOK_INPUT: JSON.stringify(payload.input) } : {},
     ...payload.output !== void 0 ? { BCCLI_HOOK_OUTPUT: payload.output } : {}
   };
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let stdout = "";
     let stderr = "";
     let timedOut = false;
@@ -2057,7 +2191,7 @@ function runOne(command, event, payload, opts) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve4(result);
+      resolve5(result);
     };
     let child;
     const shell = defaultShell();
@@ -2073,7 +2207,7 @@ function runOne(command, event, payload, opts) {
         child = spawn(command, { shell: true, env, cwd: opts.cwd ?? process.cwd(), stdio: ["ignore", "pipe", "pipe"] });
       }
     } catch (error) {
-      resolve4({ failure: error.message });
+      resolve5({ failure: error.message });
       return;
     }
     const timer = setTimeout(() => {
@@ -2128,7 +2262,9 @@ import { z as z8 } from "zod";
 
 // src/tools/bash.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync3, writeFileSync as writeFileSync2 } from "fs";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
 import { z } from "zod";
 
 // src/tools/sandbox.ts
@@ -2317,7 +2453,7 @@ function offlineEnv(env = process.env) {
   };
 }
 function runCommand(command, opts) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const child = spawnChild(command, opts.cwd, opts.env, opts.shell ?? defaultShell());
     if (!exitHookInstalled) {
       process.on("exit", killAllCommands);
@@ -2330,7 +2466,14 @@ function runCommand(command, opts) {
     let dropped = 0;
     let timedOut = false;
     let aborted = false;
+    const fullChunks = [];
+    let fullBytes = 0;
+    const MAX_SPILL_BYTES = 10 * 1024 * 1024;
     const onData = (data) => {
+      if (fullBytes < MAX_SPILL_BYTES) {
+        fullChunks.push(data);
+        fullBytes += data.length;
+      }
       let s = data;
       if (head.length < HALF) {
         const take = s.slice(0, HALF - head.length);
@@ -2369,10 +2512,19 @@ function runCommand(command, opts) {
       active.delete(killAsAborted);
       clearTimeout(timer);
       opts.signal.removeEventListener("abort", onAbort);
+      let spillNote = "";
+      if (dropped && fullChunks.length) {
+        try {
+          const spillPath = join2(tmpdir(), `bccli-bash-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.log`);
+          writeFileSync2(spillPath, fullChunks.join(""), "utf8");
+          spillNote = `; full output saved to ${spillPath}`;
+        } catch {
+        }
+      }
       const output = dropped ? `${head}
-\u2026 [${dropped} characters truncated] \u2026
+\u2026 [${dropped} characters truncated${spillNote}] \u2026
 ${tail}` : head + tail;
-      resolve4({ output: output + extra, exitCode, timedOut, aborted });
+      resolve5({ output: output + extra, exitCode, timedOut, aborted });
     };
     child.on("error", (error) => finish(null, error.message));
     child.on("close", (code) => finish(code));
@@ -2494,46 +2646,139 @@ function formatDiff(lines) {
 }
 
 // src/tools/paths.ts
+import { statSync } from "fs";
 import { isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
+var readMtimes = /* @__PURE__ */ new WeakMap();
 function resolvePath(cwd, path) {
   return isAbsolute2(path) ? path : resolve2(cwd, path);
 }
 function errorCode(error) {
   return error.code ?? error.message;
 }
+function recordFileMtime(readFiles, abs) {
+  readFiles.add(abs);
+  try {
+    let map = readMtimes.get(readFiles);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      readMtimes.set(readFiles, map);
+    }
+    map.set(abs, statSync(abs).mtimeMs);
+  } catch {
+  }
+}
+function isFileModifiedSinceRead(readFiles, abs) {
+  const recorded = readMtimes.get(readFiles)?.get(abs);
+  if (recorded === void 0) return false;
+  try {
+    return statSync(abs).mtimeMs > recorded + 50;
+  } catch {
+    return false;
+  }
+}
 
 // src/tools/edit.ts
-var schema = z2.object({
-  path: z2.string().describe("File path, relative to the project or absolute"),
+var editEntrySchema = z2.object({
   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 = z2.object({
+  path: z2.string().describe("File path, relative to the project or absolute"),
+  old_string: z2.string().optional().describe("Exact text to replace; must be unique unless replace_all"),
+  new_string: z2.string().optional().describe("Replacement text"),
+  replace_all: z2.boolean().optional().describe("Replace every occurrence"),
+  edits: z2.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 list2 = 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 (!list2.length) return { output: "Provide old_string and new_string (or edits array).", isError: true };
+  let current2 = content;
+  for (const item of list2) {
+    const next = applySingleEdit(current2, input.path, item);
+    if (typeof next !== "string") return next;
+    current2 = next;
+  }
+  return current2;
 }
 var editTool = defineTool({
   name: "edit",
@@ -2544,6 +2789,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");
@@ -2564,6 +2812,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");
@@ -2574,6 +2825,7 @@ 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)) };
   }
 });
@@ -2845,20 +3097,22 @@ async function loadPage(inputUrl, signal, pinned, fetchPage) {
 var fetchTool = createFetchTool();
 
 // src/tools/glob.ts
+import { statSync as statSync2 } from "fs";
 import { glob as nativeGlob } from "fs/promises";
+import { join as join4 } from "path";
 import { z as z4 } from "zod";
 
 // src/abort.ts
 var ABORTED = /* @__PURE__ */ Symbol("aborted");
 function raceAbort(promise, signal) {
   if (signal.aborted) return Promise.resolve(ABORTED);
-  return new Promise((resolve4, reject) => {
-    const onAbort = () => resolve4(ABORTED);
+  return new Promise((resolve5, reject) => {
+    const onAbort = () => resolve5(ABORTED);
     signal.addEventListener("abort", onAbort, { once: true });
     promise.then(
       (value) => {
         signal.removeEventListener("abort", onAbort);
-        resolve4(value);
+        resolve5(value);
       },
       (error) => {
         signal.removeEventListener("abort", onAbort);
@@ -2884,22 +3138,38 @@ async function collectUntilAbort(iterable, signal, onItem) {
 
 // src/tools/ignore.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
-function ignorePatterns(root) {
+import { dirname as dirname2, join as join3, resolve as resolve3 } from "path";
+function ignorePatterns(root, projectRoot) {
   const patterns = ["**/node_modules/**", "**/.git/**"];
-  let lines = [];
-  try {
-    lines = readFileSync2(join2(root, ".gitignore"), "utf8").split(/\r?\n/);
-  } catch {
-    return patterns;
-  }
-  for (const raw of lines) {
-    const line = raw.trim();
-    if (!line || line.startsWith("#") || line.startsWith("!")) continue;
-    const p = line.replace(/^\//, "").replace(/\/$/, "");
-    patterns.push(`**/${p}`, `**/${p}/**`);
+  const seen = /* @__PURE__ */ new Set();
+  const dirs2 = [];
+  let cur = resolve3(root);
+  const stop = projectRoot ? resolve3(projectRoot) : cur;
+  while (true) {
+    if (!seen.has(cur)) {
+      seen.add(cur);
+      dirs2.push(cur);
+    }
+    if (cur === stop || !cur.startsWith(stop)) break;
+    const parent = dirname2(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  for (const dir of dirs2) {
+    let lines = [];
+    try {
+      lines = readFileSync2(join3(dir, ".gitignore"), "utf8").split(/\r?\n/);
+    } catch {
+      continue;
+    }
+    for (const raw of lines) {
+      const line = raw.trim();
+      if (!line || line.startsWith("#") || line.startsWith("!")) continue;
+      const p = line.replace(/^\//, "").replace(/\/$/, "");
+      patterns.push(`**/${p}`, `**/${p}/**`);
+    }
   }
-  return patterns;
+  return [...new Set(patterns)];
 }
 
 // src/tools/globSafety.ts
@@ -2941,19 +3211,30 @@ var globTool = defineTool({
     path: z4.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 statSync2(join4(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 = [];
@@ -2974,75 +3255,141 @@ var globTool = defineTool({
 
 // src/tools/grep.ts
 import { execFile } from "child_process";
+import { statSync as statSync3 } from "fs";
 import { readFile as readFile2 } from "fs/promises";
 import { glob as nativeGlob2 } from "fs/promises";
+import { basename, dirname as dirname3 } from "path";
 import { z as z5 } from "zod";
 var MAX_MATCHES = 200;
 var MAX_OUTPUT_CHARS2 = 24e3;
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isSingleFile(p) {
+  try {
+    return statSync3(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 ? dirname3(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 ? dirname3(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((resolve4) => {
-    execFile("rg", args, { cwd: opts.root, maxBuffer: 10 * 1024 * 1024, signal: opts.signal }, (error, stdout) => {
-      if (opts.signal?.aborted) return resolve4([]);
+  if (opts.glob && !single) args.push("-g", opts.glob);
+  args.push("-e", pattern, target);
+  return new Promise((resolve5) => {
+    execFile("rg", args, { cwd, maxBuffer: 10 * 1024 * 1024, signal: opts.signal }, (error, stdout) => {
+      if (opts.signal?.aborted) return resolve5([]);
       const code = error?.code;
-      if (code === "ENOENT") return resolve4(void 0);
-      if (error && error.code !== 1) return resolve4(void 0);
-      resolve4(stdout.split("\n").filter(Boolean).map((l) => l.replace(/^\.\//, "")).slice(0, MAX_MATCHES));
+      if (code === "ENOENT") return resolve5(void 0);
+      if (error && error.code !== 1) return resolve5(void 0);
+      resolve5(
+        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: z5.object({
-    pattern: z5.string().describe("Regular expression"),
-    path: z5.string().optional().describe("Directory to search, default project root"),
+    pattern: z5.string().describe("Regular expression or literal string"),
+    path: z5.string().optional().describe("File or directory to search, default project root"),
     glob: z5.string().optional().describe('Only files matching this glob, e.g. "**/*.ts"'),
-    ignore_case: z5.boolean().optional()
+    ignore_case: z5.boolean().optional(),
+    literal: z5.boolean().optional().describe("Treat pattern as literal text instead of regex"),
+    context: z5.number().int().min(0).max(10).optional().describe("Number of context lines before and after each match"),
+    output_mode: z5.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 };
@@ -3064,6 +3411,7 @@ var grepTool = defineTool({
 });
 
 // src/tools/read.ts
+import { readdirSync, statSync as statSync4 } from "fs";
 import { readFile as readFile3 } from "fs/promises";
 import { z as z6 } from "zod";
 var MAX_LINE = 2e3;
@@ -3147,6 +3495,16 @@ function createReadTool(options = {}) {
     target: (input) => input.path,
     async run(input, ctx) {
       const abs = resolvePath(ctx.cwd, input.path);
+      try {
+        if (statSync4(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);
@@ -3155,13 +3513,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);
     }
   });
@@ -3171,7 +3529,7 @@ var readTool = createReadTool({ vision: true });
 // src/tools/write.ts
 import { existsSync as existsSync4 } from "fs";
 import { mkdir, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname4 } from "path";
 import { z as z7 } from "zod";
 var writeTool = defineTool({
   name: "write",
@@ -3198,12 +3556,12 @@ var writeTool = defineTool({
     }
     try {
       await ctx.checkpoint?.(abs);
-      await mkdir(dirname2(abs), { recursive: true });
+      await mkdir(dirname4(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 }) };
   }
@@ -3313,12 +3671,36 @@ function budgetStatus(usage, cap, model) {
 }
 
 // src/tokenBudget.ts
+var IMAGE_TOKEN_COST = 1e3;
 var estimateTokens = (text) => Math.ceil(text.length / 4);
-var estimateMessages = (messages) => estimateTokens(JSON.stringify(messages));
+function isImageAttachmentMessage(m) {
+  if (m.role !== "user" || !Array.isArray(m.content)) return false;
+  const hasImage = m.content.some((p) => p.type === "image_url");
+  const firstText = m.content.find((p) => p.type === "text");
+  return hasImage && !!firstText && firstText.type === "text" && firstText.text.startsWith("Image read from ");
+}
+function isUserTurnBoundary(m) {
+  return m.role === "user" && !isImageAttachmentMessage(m);
+}
+function estimateMessages(messages) {
+  let total = 0;
+  for (const m of messages) {
+    if (m.role === "user" && Array.isArray(m.content)) {
+      for (const part of m.content) {
+        if (part.type === "image_url") total += IMAGE_TOKEN_COST;
+        else total += estimateTokens(part.text);
+      }
+      total += 8;
+    } else {
+      total += estimateTokens(JSON.stringify(m));
+    }
+  }
+  return total;
+}
 function trimToFit(messages, maxTokens) {
   let out = messages;
   while (estimateMessages(out) > maxTokens) {
-    const boundary = out.findIndex((m, i) => i > 0 && m.role === "user");
+    const boundary = out.findIndex((m, i) => i > 0 && isUserTurnBoundary(m));
     if (boundary === -1) return out;
     out = out.slice(boundary);
   }
@@ -3328,13 +3710,13 @@ function splitKeepRecent(messages, keepTokens) {
   if (messages.length === 0) return [[], []];
   let start = messages.length;
   for (let i = messages.length - 1; i >= 0; i--) {
-    if (i > 0 && messages[i].role !== "user") continue;
+    if (i > 0 && !isUserTurnBoundary(messages[i])) continue;
     if (estimateMessages(messages.slice(i)) <= keepTokens) start = i;
     else break;
   }
   if (start === messages.length) {
     for (let i = messages.length - 1; i >= 0; i--) {
-      if (messages[i].role === "user") {
+      if (isUserTurnBoundary(messages[i])) {
         start = i;
         break;
       }
@@ -3382,6 +3764,7 @@ var Agent2 = 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";
   }
@@ -3405,6 +3788,7 @@ var Agent2 = class {
   maxSteps;
   // One window for every model; resolved from contextWindowFor() (catalog + env override).
   contextWindow;
+  budgetModel;
   systemPrompt;
   setSystemPrompt(text) {
     this.systemPrompt = text;
@@ -3412,6 +3796,15 @@ var Agent2 = 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);
@@ -3612,7 +4005,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) {
@@ -3732,7 +4125,7 @@ ${t("This model may not support tool calling. Try another model with /model.")}`
 };
 
 // src/checkpoints.ts
-import { existsSync as existsSync5, statSync } from "fs";
+import { existsSync as existsSync5, statSync as statSync5 } from "fs";
 import { readFile as readFile5, rm, writeFile as writeFile3 } from "fs/promises";
 var MAX_TURNS = 20;
 var MAX_BYTES2 = 2 * 1024 * 1024;
@@ -3759,8 +4152,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;
@@ -3771,16 +4164,19 @@ var CheckpointStore = class {
     const turn = this.current;
     if (turn.has(path)) return;
     if (!existsSync5(path)) turn.set(path, null);
-    else if (statSync(path).size > MAX_BYTES2) turn.set(path, "skipped");
+    else if (statSync5(path).size > MAX_BYTES2) 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();
@@ -3800,7 +4196,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;
@@ -3825,8 +4221,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. */
@@ -3839,7 +4238,7 @@ var CheckpointStore = class {
       }
       try {
         if (!existsSync5(path)) into.set(path, null);
-        else if (statSync(path).size > MAX_BYTES2) into.set(path, "skipped");
+        else if (statSync5(path).size > MAX_BYTES2) into.set(path, "skipped");
         else into.set(path, await readFile5(path));
       } catch {
         into.set(path, "skipped");
@@ -3850,6 +4249,7 @@ var CheckpointStore = class {
     this.history.length = 0;
     this.current = void 0;
     this.pendingRedo = void 0;
+    this.offset = 0;
   }
 };
 
@@ -3897,8 +4297,8 @@ import { z as z9 } from "zod";
 
 // src/mcp/config.ts
 import { createHash } from "crypto";
-import { chmodSync as chmodSync2, existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname3, join as join3, resolve as resolve3 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname5, join as join5, resolve as resolve4 } from "path";
 var ENV_REF = /\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g;
 function expandEnvVars(config, env) {
   const expand = (value) => value.replace(ENV_REF, (match, name, fallback) => {
@@ -3920,33 +4320,39 @@ function expandEnvVars(config, env) {
 
 // src/mcp/oauth.ts
 import { spawn as spawn3 } from "child_process";
-import { chmodSync as chmodSync3, existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync4 } from "fs";
 import { createServer } from "http";
-import { dirname as dirname4, join as join4 } from "path";
+import { dirname as dirname6, join as join6 } from "path";
 import { auth } from "@modelcontextprotocol/sdk/client/auth.js";
-var oauthStorePath = (home) => join4(home, "mcp-oauth.json");
+var oauthStorePath = (home) => join6(home, "mcp-oauth.json");
 function readStore(home) {
   const path = oauthStorePath(home);
   if (!existsSync7(path)) return {};
   try {
     return JSON.parse(readFileSync4(path, "utf8"));
-  } catch {
+  } catch (error) {
+    quarantineCorruptFile(path, error);
     return {};
   }
 }
 function writeStore(home, store) {
   const path = oauthStorePath(home);
-  mkdirSync3(dirname4(path), { recursive: true });
-  writeFileSync3(path, `${JSON.stringify(store, null, 2)}
-`, { mode: 384 });
-  chmodSync3(path, 384);
+  mkdirSync3(dirname6(path), { recursive: true });
+  writeFileAtomic(path, `${JSON.stringify(store, null, 2)}
+`, 384);
 }
 function hasStoredTokens(home, serverUrl) {
   return Boolean(readStore(home)[serverUrl]?.tokens);
 }
-function defaultOpen(url) {
-  const target = url.href;
-  const child = process.platform === "win32" ? spawn3("cmd", ["/c", "start", "", target], { detached: true, stdio: "ignore" }) : spawn3(process.platform === "darwin" ? "open" : "xdg-open", [target], { detached: true, stdio: "ignore" });
+function openCommand(url, platform) {
+  if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+  if (platform === "win32") return { command: "rundll32.exe", args: ["url.dll,FileProtocolHandler", url.href] };
+  return { command: platform === "darwin" ? "open" : "xdg-open", args: [url.href] };
+}
+function defaultOpen(url, deps = {}) {
+  const plan = openCommand(url, deps.platform ?? process.platform);
+  if (!plan) return;
+  const child = (deps.spawn ?? spawn3)(plan.command, plan.args, { detached: true, stdio: "ignore" });
   child.unref();
   child.on("error", () => {
   });
@@ -4025,7 +4431,28 @@ var FileOAuthProvider = class {
 };
 
 // src/mcp/manager.ts
-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",
@@ -4154,11 +4581,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 };
@@ -4192,8 +4621,8 @@ import { homedir as homedir2 } from "os";
 
 // src/context.ts
 import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname5, join as join5 } from "path";
-var FILES = ["AGENTS.md", "BCCLI.md"];
+import { dirname as dirname7, join as join7 } from "path";
+var FILES = ["AGENTS.md", "CLAUDE.md", "BCCLI.md"];
 function readIf(path) {
   try {
     return existsSync8(path) ? readFileSync5(path, "utf8").trim() : void 0;
@@ -4203,11 +4632,11 @@ function readIf(path) {
 }
 function instructionPaths(cwd, home) {
   const dirs2 = [];
-  for (let dir = cwd; ; dir = dirname5(dir)) {
+  for (let dir = cwd; ; dir = dirname7(dir)) {
     dirs2.unshift(dir);
-    if (dirname5(dir) === dir) break;
+    if (dirname7(dir) === dir) break;
   }
-  return [join5(home, "BCCLI.md"), ...dirs2.flatMap((dir) => FILES.map((name) => join5(dir, name)))];
+  return [join7(home, "BCCLI.md"), ...dirs2.flatMap((dir) => FILES.map((name) => join7(dir, name)))];
 }
 function loadInstructions(cwd, home) {
   const parts = [];
@@ -4219,9 +4648,9 @@ ${text}`);
   return parts.join("\n\n");
 }
 function isGitRepo(cwd) {
-  for (let dir = cwd; ; dir = dirname5(dir)) {
-    if (existsSync8(join5(dir, ".git"))) return true;
-    if (dirname5(dir) === dir) return false;
+  for (let dir = cwd; ; dir = dirname7(dir)) {
+    if (existsSync8(join7(dir, ".git"))) return true;
+    if (dirname7(dir) === dir) return false;
   }
 }
 function buildSystemPrompt(opts) {
@@ -4264,16 +4693,34 @@ ${instructions}` : ""}`;
 }
 
 // src/extensions.ts
-import { existsSync as existsSync9, readdirSync, readFileSync as readFileSync6, statSync as statSync2 } from "fs";
-import { basename, join as join6 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync2, readFileSync as readFileSync6, statSync as statSync6 } from "fs";
+import { basename as basename2, join as join8 } from "path";
 function parseFrontmatter(text) {
   const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
   if (!match) return { data: {}, body: text };
   const data = {};
+  let currentListKey;
   for (const line of match[1].split(/\r?\n/)) {
+    const listItem = /^\s*-\s+(.+)$/.exec(line);
+    if (listItem && currentListKey) {
+      const item = listItem[1].trim().replace(/^["']|["']$/g, "");
+      const prev = data[currentListKey];
+      if (Array.isArray(prev)) prev.push(item);
+      else data[currentListKey] = [item];
+      continue;
+    }
     const kv = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line);
-    if (!kv) continue;
+    if (!kv) {
+      if (line.trim()) currentListKey = void 0;
+      continue;
+    }
     let value = kv[2].trim();
+    if (!value) {
+      currentListKey = kv[1];
+      data[kv[1]] = "";
+      continue;
+    }
+    currentListKey = void 0;
     if (value.startsWith("[") && value.endsWith("]")) {
       data[kv[1]] = value.slice(1, -1).split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
       continue;
@@ -4285,11 +4732,11 @@ function parseFrontmatter(text) {
 }
 var str = (v) => Array.isArray(v) ? v.join(", ") : v;
 function dirs(r, kind) {
-  return [join6(r.userHome, ".claude", kind), join6(r.home, kind), join6(r.cwd, ".claude", kind), join6(r.cwd, ".bccli", kind)];
+  return [join8(r.userHome, ".claude", kind), join8(r.home, kind), join8(r.cwd, ".claude", kind), join8(r.cwd, ".bccli", kind)];
 }
 function list(dir) {
   try {
-    return readdirSync(dir).sort();
+    return readdirSync2(dir).sort();
   } catch {
     return [];
   }
@@ -4298,11 +4745,11 @@ function loadSkills(r) {
   const byName = /* @__PURE__ */ new Map();
   for (const dir of dirs(r, "skills")) {
     for (const entry of list(dir)) {
-      const file = join6(dir, entry, "SKILL.md");
+      const file = join8(dir, entry, "SKILL.md");
       if (!existsSync9(file)) continue;
       const { data } = parseFrontmatter(readFileSync6(file, "utf8"));
       const name = str(data.name) || entry;
-      byName.set(name, { name, description: str(data.description) ?? "", dir: join6(dir, entry), file });
+      byName.set(name, { name, description: str(data.description) ?? "", dir: join8(dir, entry), file });
     }
   }
   return [...byName.values()];
@@ -4311,10 +4758,10 @@ function loadCommands(r) {
   const byName = /* @__PURE__ */ new Map();
   for (const dir of dirs(r, "commands")) {
     for (const entry of list(dir)) {
-      const file = join6(dir, entry);
-      if (!entry.endsWith(".md") || !statSync2(file).isFile()) continue;
+      const file = join8(dir, entry);
+      if (!entry.endsWith(".md") || !statSync6(file).isFile()) continue;
       const { data, body } = parseFrontmatter(readFileSync6(file, "utf8"));
-      const def = { name: basename(entry, ".md"), body: body.trim() };
+      const def = { name: basename2(entry, ".md"), body: body.trim() };
       if (data.description) def.description = str(data.description);
       if (data["argument-hint"]) def.argumentHint = str(data["argument-hint"]);
       byName.set(def.name, def);
@@ -4327,8 +4774,8 @@ function loadAgentDefs(r) {
   for (const dir of dirs(r, "agents")) {
     for (const entry of list(dir)) {
       if (!entry.endsWith(".md")) continue;
-      const { data, body } = parseFrontmatter(readFileSync6(join6(dir, entry), "utf8"));
-      const name = str(data.name) || basename(entry, ".md");
+      const { data, body } = parseFrontmatter(readFileSync6(join8(dir, entry), "utf8"));
+      const name = str(data.name) || basename2(entry, ".md");
       const def = { name, description: str(data.description) ?? "", prompt: body.trim() };
       if (data.tools)
         def.tools = Array.isArray(data.tools) ? data.tools : String(data.tools).split(",").map((s) => s.trim()).filter(Boolean);
@@ -4346,8 +4793,7 @@ function loadAgentDefs(r) {
 }
 
 // src/providers.ts
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
-import { join as join7 } from "path";
+import { join as join9 } from "path";
 function providerName(config, id) {
   return PRESETS.find((p) => p.id === id)?.name ?? config.providers[id]?.name ?? id;
 }
@@ -4406,11 +4852,11 @@ async function addProviderKey(providerId, key, deps) {
 
 // src/session.ts
 import { randomBytes as randomBytes2 } from "crypto";
-import { appendFileSync, existsSync as existsSync10, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync7, rmSync as rmSync2, statSync as statSync3 } from "fs";
-import { join as join8 } from "path";
+import { appendFileSync, existsSync as existsSync10, mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync7, rmSync as rmSync2, statSync as statSync7 } from "fs";
+import { basename as basename3, join as join10 } from "path";
 function projectDir(home, cwd) {
   const slug = cwd.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(-100) || "root";
-  return join8(home, "sessions", slug);
+  return join10(home, "sessions", slug);
 }
 function repairTail(messages) {
   const out = [...messages];
@@ -4428,19 +4874,22 @@ var Session = class _Session {
     this.file = file;
   }
   file;
+  get id() {
+    return basename3(this.file, ".jsonl");
+  }
   static create(home, cwd, now = /* @__PURE__ */ new Date()) {
     const dir = projectDir(home, cwd);
-    mkdirSync5(dir, { recursive: true });
+    mkdirSync4(dir, { recursive: true });
     const stamp = now.toISOString().replace(/[:.]/g, "-");
-    return new _Session(join8(dir, `${stamp}-${randomBytes2(3).toString("hex")}.jsonl`));
+    return new _Session(join10(dir, `${stamp}-${randomBytes2(3).toString("hex")}.jsonl`));
   }
   static list(home, cwd) {
     const dir = projectDir(home, cwd);
     if (!existsSync10(dir)) return [];
-    return readdirSync2(dir).filter((f) => f.endsWith(".jsonl")).map((f) => {
-      const session = new _Session(join8(dir, f));
-      const first = session.load().find((m) => m.role === "user");
-      return { session, mtime: statSync3(session.file).mtime, preview: first ? contentText(first.content).slice(0, 80) : "" };
+    return readdirSync3(dir).filter((f) => f.endsWith(".jsonl")).map((f) => {
+      const session = new _Session(join10(dir, f));
+      const first = session.loadHistory().find((m) => m.role === "user");
+      return { session, mtime: statSync7(session.file).mtime, preview: first ? contentText(first.content).slice(0, 80) : "" };
     }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime() || b.session.file.localeCompare(a.session.file));
   }
   static latest(home, cwd) {
@@ -4480,6 +4929,44 @@ var Session = class _Session {
     }
     return repairTail(messages);
   }
+  /** Model of the most recent turn that recorded usage — serve attach continues a session with its own model. */
+  lastModel() {
+    const records = this.records();
+    for (let i = records.length - 1; i >= 0; i--) {
+      const record = records[i];
+      if (record.t === "usage" && record.model) return record.model;
+    }
+    return void 0;
+  }
+  /** Accumulated token usage since the last non-compaction reset. */
+  totalUsage() {
+    const segments = [{ msgs: [], usage: { inputTokens: 0, outputTokens: 0 } }];
+    for (const record of this.records()) {
+      const cur = segments[segments.length - 1];
+      if (record.t === "reset") {
+        segments.push({ msgs: [], usage: { inputTokens: 0, outputTokens: 0 } });
+      } else if (record.t === "msg") {
+        cur.msgs.push(record.m);
+      } else if (record.t === "usage") {
+        cur.usage.inputTokens += record.inputTokens;
+        cur.usage.outputTokens += record.outputTokens;
+        if (record.cachedInputTokens) cur.usage.cachedInputTokens = (cur.usage.cachedInputTokens ?? 0) + record.cachedInputTokens;
+        if (record.cacheWriteTokens) cur.usage.cacheWriteTokens = (cur.usage.cacheWriteTokens ?? 0) + record.cacheWriteTokens;
+      }
+    }
+    let total = { ...segments[0].usage };
+    for (const seg of segments.slice(1)) {
+      if (!isCompactionSummary(seg.msgs[0])) {
+        total = { ...seg.usage };
+      } else {
+        total.inputTokens += seg.usage.inputTokens;
+        total.outputTokens += seg.usage.outputTokens;
+        if (seg.usage.cachedInputTokens) total.cachedInputTokens = (total.cachedInputTokens ?? 0) + seg.usage.cachedInputTokens;
+        if (seg.usage.cacheWriteTokens) total.cacheWriteTokens = (total.cacheWriteTokens ?? 0) + seg.usage.cacheWriteTokens;
+      }
+    }
+    return total;
+  }
   /**
    * What the user sees on resume: the whole conversation. Compaction only shrinks what the model is sent, so
    * its reset does not hide the older turns here. A real reset (/clear, rewind) still starts over, the
@@ -4492,12 +4979,22 @@ var Session = class _Session {
       else if (record.t === "msg") segments[segments.length - 1].push(record.m);
     }
     let shown = segments[0];
+    let lastSummary;
     for (const segment of segments.slice(1)) {
       if (!isCompactionSummary(segment[0])) {
         shown = segment;
+        lastSummary = void 0;
         continue;
       }
       const kept = segment.slice(2);
+      if (lastSummary && sameMessage2(segment[0], lastSummary)) {
+        const subIdx = findContiguousSlice(shown, kept);
+        if (subIdx !== -1) {
+          shown = shown.slice(0, subIdx + kept.length);
+          continue;
+        }
+      }
+      lastSummary = segment[0];
       let at = 0;
       while (at <= shown.length && !endsWithPrefixOf(shown, at, kept)) at++;
       shown = [...shown, ...kept.slice(shown.length - at)];
@@ -4524,6 +5021,20 @@ function endsWithPrefixOf(shown, at, kept) {
   for (let j = 0; j < n; j++) if (!sameMessage2(shown[at + j], kept[j])) return false;
   return true;
 }
+function findContiguousSlice(shown, slice) {
+  if (slice.length === 0) return shown.length;
+  for (let i = 0; i + slice.length <= shown.length; i++) {
+    let ok = true;
+    for (let j = 0; j < slice.length; j++) {
+      if (!sameMessage2(shown[i + j], slice[j])) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok) return i;
+  }
+  return -1;
+}
 
 // src/tools/plan.ts
 import { z as z10 } from "zod";
@@ -4633,6 +5144,7 @@ import { z as z13 } from "zod";
 function createTaskTool(opts) {
   const byName = new Map(opts.agents.map((a) => [a.name, a]));
   const list2 = 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(
@@ -4652,7 +5164,8 @@ ${list2}`,
     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")
+      prompt: z13.string().describe("Full instructions; the subagent sees nothing else"),
+      session_id: z13.string().optional().describe("Optional session id to continue a previous subagent conversation")
     }),
     kind: "read",
     target: (input) => `[${input.agent}] ${input.description}`,
@@ -4679,6 +5192,7 @@ ${list2}`,
       } 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 Agent2({
         provider,
         tools,
@@ -4688,6 +5202,7 @@ ${list2}`,
 # 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,
@@ -4708,12 +5223,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" ? `
 
@@ -4759,7 +5291,7 @@ function createTodoTool(store) {
 
 // src/tools/memory.ts
 import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
-import { join as join9 } from "path";
+import { join as join11 } from "path";
 import { z as z15 } from "zod";
 
 // src/slash/memory.ts
@@ -4782,11 +5314,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" ? join9(opts.home, "BCCLI.md") : "AGENTS.md",
+    target: (input) => input.scope === "global" ? join11(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" ? join9(opts.home, "BCCLI.md") : join9(ctx.cwd, "AGENTS.md");
+      const file = input.scope === "global" ? join11(opts.home, "BCCLI.md") : join11(ctx.cwd, "AGENTS.md");
       if (existsSync12(file)) {
         const lines = readFileSync10(file, "utf8").split("\n");
         if (lines.some((line) => line.trim() === `- ${content}`)) {
@@ -4804,18 +5336,21 @@ function createSaveMemoryTool(opts) {
 import { z as z16 } from "zod";
 
 // src/repomap.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync11 } from "fs";
-import { extname, join as join10, relative as relative2, sep as sep2 } from "path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync11 } from "fs";
+import { extname, join as join12, relative as relative2, sep } from "path";
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
   "dist",
   "build",
+  "out",
   "coverage",
   ".next",
+  ".turbo",
   "target",
   "vendor",
   "__pycache__",
+  "venv",
   ".venv",
   ".cache"
 ]);
@@ -4841,21 +5376,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;
@@ -4875,16 +5411,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 = readdirSync3(dir, { withFileTypes: true });
+    entries = readdirSync4(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 = join10(dir, e.name);
+    if (files.length >= MAX_SCAN_FILES) return;
+    const full = join12(dir, e.name);
     if (e.isDirectory()) {
       if (SKIP_DIRS.has(e.name) || e.name.startsWith(".") && full !== root) continue;
       walk(full, root, files);
@@ -4895,16 +5431,17 @@ function walk(dir, root, files) {
 }
 function buildRepoMapSync(cwd, opts = {}) {
   const maxTokens = opts.maxTokens ?? 2048;
-  const files = [];
-  walk(cwd, cwd, files);
-  files.sort(
-    (a, b) => relative2(cwd, a).split(sep2).length - relative2(cwd, b).split(sep2).length || a.localeCompare(b)
+  const scanned = [];
+  walk(cwd, cwd, scanned);
+  scanned.sort(
+    (a, b) => relative2(cwd, a).split(sep).length - relative2(cwd, b).split(sep).length || a.localeCompare(b)
   );
+  const files = scanned.slice(0, MAX_FILES);
   const lines = [];
   let used = 0;
   let truncated = false;
   for (const file of files) {
-    const rel = relative2(cwd, file).split(sep2).join("/");
+    const rel = relative2(cwd, file).split(sep).join("/");
     let symbols = [];
     try {
       const text = readFileSync11(file, "utf8");
@@ -4939,13 +5476,50 @@ function createRepoMapTool() {
 }
 
 // src/tools/diagnostics.ts
-import { extname as extname2 } from "path";
+import { extname as extname3 } from "path";
 import { z as z17 } from "zod";
 
 // src/lsp.ts
 import { spawn as spawn4 } from "child_process";
 import { readFileSync as readFileSync12 } from "fs";
+import { extname as extname2 } from "path";
 import { 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
@@ -4978,8 +5552,12 @@ function createLspParser(onMessage) {
   };
 }
 function getDiagnostics(opts) {
-  return new Promise((resolve4) => {
-    const child = spawn4(opts.server.command, opts.server.args ?? [], { cwd: opts.cwd, stdio: ["pipe", "pipe", "ignore"] });
+  return new Promise((resolve5) => {
+    const child = spawn4(opts.server.command, opts.server.args ?? [], {
+      cwd: opts.cwd,
+      stdio: ["pipe", "pipe", "ignore"],
+      shell: useShellForLsp(opts.server.command)
+    });
     const uri = pathToFileURL(opts.file).href;
     let settled = false;
     let nextId = 2;
@@ -4993,6 +5571,7 @@ function getDiagnostics(opts) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
+      opts.signal?.removeEventListener("abort", onAbort);
       send({ jsonrpc: "2.0", id: nextId++, method: "shutdown" });
       send({ jsonrpc: "2.0", method: "exit" });
       const killer = setTimeout(() => {
@@ -5002,8 +5581,11 @@ function getDiagnostics(opts) {
         }
       }, 500);
       killer.unref?.();
-      resolve4(diags);
+      resolve5(diags);
     };
+    const onAbort = () => finish([]);
+    if (opts.signal?.aborted) return finish([]);
+    opts.signal?.addEventListener("abort", onAbort, { once: true });
     const timer = setTimeout(() => finish([]), opts.timeoutMs ?? 8e3);
     const parser = createLspParser((msg) => {
       if (msg.id === 1 && msg.result) {
@@ -5016,7 +5598,7 @@ function getDiagnostics(opts) {
         send({
           jsonrpc: "2.0",
           method: "textDocument/didOpen",
-          params: { textDocument: { uri, languageId: "plaintext", version: 1, text } }
+          params: { textDocument: { uri, languageId: languageIdFor(opts.file), version: 1, text } }
         });
       }
       if (msg.method === "textDocument/publishDiagnostics" && msg.params?.uri === uri) {
@@ -5054,7 +5636,7 @@ function createDiagnosticsTool(servers) {
     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 };
@@ -5070,7 +5652,7 @@ function createDiagnosticsTool(servers) {
 // src/plugins.ts
 import { existsSync as existsSync13 } from "fs";
 import { createRequire } from "module";
-import { isAbsolute as isAbsolute3, join as join11 } from "path";
+import { isAbsolute as isAbsolute3, join as join13 } from "path";
 import { z as z18 } from "zod";
 var require_ = createRequire(import.meta.url);
 function pluginLog(message) {
@@ -5095,7 +5677,7 @@ function loadPlugins(specs, opts) {
   for (const spec of specs) {
     let file;
     try {
-      file = isAbsolute3(spec) ? spec : spec.startsWith(".") ? join11(opts.home, spec) : require_.resolve(spec);
+      file = isAbsolute3(spec) ? spec : spec.startsWith(".") ? join13(opts.home, spec) : require_.resolve(spec);
     } catch {
       throw new ConfigError(t("Plugin not found: {spec}", { spec }));
     }
@@ -5172,7 +5754,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,
@@ -5184,6 +5766,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)];
@@ -5205,6 +5806,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;
@@ -5248,7 +5853,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,
@@ -5334,6 +5939,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;
@@ -5382,6 +6001,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));
     },
@@ -5407,6 +6027,7 @@ async function* streamTask(opts) {
   let finished = false;
   let text = "";
   let stopReason = "done";
+  let errorMessage2;
   const usage = { inputTokens: 0, outputTokens: 0 };
   const toolCalls = [];
   const byId = /* @__PURE__ */ new Map();
@@ -5456,28 +6077,45 @@ async function* streamTask(opts) {
       case "aborted":
         stopReason = "aborted";
         break;
+      case "error":
+        stopReason = "error";
+        errorMessage2 = event.message;
+        push({ type: "error", message: event.message });
+        break;
       default:
         break;
     }
   };
-  const running = rt.agent.run(opts.prompt, opts.signal ?? new AbortController().signal).catch(() => {
-    stopReason = "aborted";
+  const controller = new AbortController();
+  const onParentAbort = () => controller.abort();
+  if (opts.signal) {
+    if (opts.signal.aborted) controller.abort();
+    else opts.signal.addEventListener("abort", onParentAbort, { once: true });
+  }
+  const running = rt.agent.run(opts.prompt, controller.signal).catch((err) => {
+    stopReason = "error";
+    errorMessage2 = err instanceof Error ? err.message : String(err);
   }).finally(() => {
     finished = true;
     wake?.();
   });
-  while (!finished || queue.length) {
-    if (queue.length) {
-      yield queue.shift();
-      continue;
+  try {
+    while (!finished || queue.length) {
+      if (queue.length) {
+        yield queue.shift();
+        continue;
+      }
+      await new Promise((resolve5) => {
+        wake = resolve5;
+      });
+      wake = null;
     }
-    await new Promise((resolve4) => {
-      wake = resolve4;
-    });
-    wake = null;
+    await running;
+    yield { type: "result", result: { text, toolCalls, usage, stopReason, ...errorMessage2 ? { error: errorMessage2 } : {} } };
+  } finally {
+    opts.signal?.removeEventListener("abort", onParentAbort);
+    if (!finished) controller.abort();
   }
-  await running;
-  yield { type: "result", result: { text, toolCalls, usage, stopReason } };
 }
 async function runTask(opts) {
   let out = { text: "", toolCalls: [], usage: { inputTokens: 0, outputTokens: 0 }, stopReason: "done" };