zidane 3.0.2 → 3.1.1

package/dist/{chunk-QFHGWKK3.js → chunk-EBSFBIP3.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-TPXPVEH6.js";
 import {
   createProcessContext
-} from "./chunk-2EQT4EHD.js";
+} from "./chunk-IUBBVF53.js";
 import {
   connectMcpServers
 } from "./chunk-R74LQKAM.js";
@@ -36,6 +36,175 @@ function countExactMatches(haystack, needle) {
   }
   return count;
 }
+var LEFT_SINGLE_CURLY_QUOTE = "\u2018";
+var RIGHT_SINGLE_CURLY_QUOTE = "\u2019";
+var LEFT_DOUBLE_CURLY_QUOTE = "\u201C";
+var RIGHT_DOUBLE_CURLY_QUOTE = "\u201D";
+function normalizeQuotes(str) {
+  return str.replaceAll(LEFT_SINGLE_CURLY_QUOTE, "'").replaceAll(RIGHT_SINGLE_CURLY_QUOTE, "'").replaceAll(LEFT_DOUBLE_CURLY_QUOTE, '"').replaceAll(RIGHT_DOUBLE_CURLY_QUOTE, '"');
+}
+var DESANITIZATIONS = [
+  ["<fnr>", "<function_results>"],
+  ["<n>", "<name>"],
+  ["</n>", "</name>"],
+  ["<o>", "<output>"],
+  ["</o>", "</output>"],
+  ["<e>", "<error>"],
+  ["</e>", "</error>"],
+  ["<s>", "<system>"],
+  ["</s>", "</system>"],
+  ["<r>", "<result>"],
+  ["</r>", "</result>"],
+  ["< META_START >", "<META_START>"],
+  ["< META_END >", "<META_END>"],
+  ["< EOT >", "<EOT>"],
+  ["< META >", "<META>"],
+  ["< SOS >", "<SOS>"],
+  ["\n\nH:", "\n\nHuman:"],
+  ["\n\nA:", "\n\nAssistant:"]
+];
+function desanitize(s) {
+  let out = s;
+  for (const [from, to] of DESANITIZATIONS)
+    out = out.replaceAll(from, to);
+  return out;
+}
+function resolveOldString(haystack, needle) {
+  const exact = countExactMatches(haystack, needle);
+  if (exact > 0)
+    return { actual: needle, occurrences: exact, via: "exact" };
+  const normNeedle = normalizeQuotes(needle);
+  const normFile = normalizeQuotes(haystack);
+  if (normNeedle !== needle || normFile !== haystack) {
+    const idx = normFile.indexOf(normNeedle);
+    if (idx !== -1) {
+      const actual = haystack.slice(idx, idx + normNeedle.length);
+      let occ = 0;
+      let cursor = 0;
+      while (true) {
+        const next = normFile.indexOf(normNeedle, cursor);
+        if (next === -1)
+          break;
+        occ++;
+        cursor = next + normNeedle.length;
+      }
+      return { actual, occurrences: occ, via: "quotes" };
+    }
+  }
+  const desan = desanitize(needle);
+  if (desan !== needle) {
+    const desanCount = countExactMatches(haystack, desan);
+    if (desanCount > 0)
+      return { actual: desan, occurrences: desanCount, via: "desanitize" };
+  }
+  const combo = desanitize(normNeedle);
+  if (combo !== needle) {
+    const idx = normFile.indexOf(combo);
+    if (idx !== -1) {
+      const actual = haystack.slice(idx, idx + combo.length);
+      let occ = 0;
+      let cursor = 0;
+      while (true) {
+        const next = normFile.indexOf(combo, cursor);
+        if (next === -1)
+          break;
+        occ++;
+        cursor = next + combo.length;
+      }
+      return { actual, occurrences: occ, via: "quotes+desanitize" };
+    }
+  }
+  return null;
+}
+function preserveQuoteStyle(actual, replacement) {
+  const hasDouble = actual.includes(LEFT_DOUBLE_CURLY_QUOTE) || actual.includes(RIGHT_DOUBLE_CURLY_QUOTE);
+  const hasSingle = actual.includes(LEFT_SINGLE_CURLY_QUOTE) || actual.includes(RIGHT_SINGLE_CURLY_QUOTE);
+  if (!hasDouble && !hasSingle)
+    return replacement;
+  let out = replacement;
+  if (hasDouble)
+    out = applyCurly(out, '"', LEFT_DOUBLE_CURLY_QUOTE, RIGHT_DOUBLE_CURLY_QUOTE, false);
+  if (hasSingle)
+    out = applyCurly(out, "'", LEFT_SINGLE_CURLY_QUOTE, RIGHT_SINGLE_CURLY_QUOTE, true);
+  return out;
+}
+function applyCurly(s, straight, left, right, contractionAware) {
+  const chars = [...s];
+  const result = [];
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] !== straight) {
+      result.push(chars[i]);
+      continue;
+    }
+    if (contractionAware) {
+      const prev = i > 0 ? chars[i - 1] : "";
+      const next = i < chars.length - 1 ? chars[i + 1] : "";
+      if (/\p{L}/u.test(prev) && /\p{L}/u.test(next)) {
+        result.push(right);
+        continue;
+      }
+    }
+    result.push(isOpeningContext(chars, i) ? left : right);
+  }
+  return result.join("");
+}
+function isOpeningContext(chars, i) {
+  if (i === 0)
+    return true;
+  const prev = chars[i - 1];
+  return prev === " " || prev === "	" || prev === "\n" || prev === "\r" || prev === "(" || prev === "[" || prev === "{" || prev === "\u2014" || prev === "\u2013";
+}
+
+// src/tools/path-suggest.ts
+async function findSimilarFile(execution, handle, path) {
+  const slash = path.lastIndexOf("/");
+  const dir = slash === -1 ? "." : path.slice(0, slash) || "/";
+  const target = slash === -1 ? path : path.slice(slash + 1);
+  const dot = target.lastIndexOf(".");
+  const targetBase = dot === -1 ? target : target.slice(0, dot);
+  if (targetBase.length === 0)
+    return null;
+  let entries;
+  try {
+    entries = await execution.listFiles(handle, dir);
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    if (entry === target)
+      continue;
+    const entryDot = entry.lastIndexOf(".");
+    const entryBase = entryDot === -1 ? entry : entry.slice(0, entryDot);
+    if (entryBase === targetBase)
+      return entry;
+  }
+  return null;
+}
+async function suggestionFor(execution, handle, path) {
+  const sibling = await findSimilarFile(execution, handle, path);
+  return sibling ? ` Did you mean ${sibling}?` : "";
+}
+
+// src/tools/read-state.ts
+var STATE = /* @__PURE__ */ new WeakMap();
+function getReadState(session) {
+  if (!session)
+    return void 0;
+  let map = STATE.get(session);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    STATE.set(session, map);
+  }
+  return map;
+}
+function hashContent(text) {
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24)) >>> 0;
+  }
+  return h.toString(16).padStart(8, "0");
+}
 
 // src/tools/edit.ts
 var edit = {
@@ -66,19 +235,41 @@ var edit = {
     try {
       original = await ctx.execution.readFile(ctx.handle, target);
     } catch {
-      return `Edit error: file not found: ${target}`;
-    }
-    const occurrences = countExactMatches(original, find);
-    if (occurrences === 0) {
+      const hint = await suggestionFor(ctx.execution, ctx.handle, target);
+      return `Edit error: file not found: ${target}.${hint}`;
+    }
+    if (ctx.behavior?.requireReadBeforeEdit && ctx.session) {
+      const readState = getReadState(ctx.session);
+      const absKey = `${ctx.handle.cwd}::${target}`;
+      const prior = readState?.get(absKey);
+      if (!prior)
+        return `Edit error: ${target} has not been read in this session. Call read_file first so the edit applies against the current contents.`;
+      if (prior.contentHash !== hashContent(original))
+        return `Edit error: ${target} has changed on disk since the last read. Re-read the file before editing.`;
+    }
+    const match = resolveOldString(original, find);
+    if (!match) {
       const preview = nearestMatchPreview(original, find);
       return preview ? `Edit error: old_string not found in ${target}. Closest match in the file: ${preview}` : `Edit error: old_string not found in ${target}.`;
     }
+    const { actual, occurrences, via } = match;
     if (occurrences > 1 && !replaceAll)
       return `Edit error: old_string appears ${occurrences} times in ${target}. Pass replace_all=true or expand old_string for uniqueness.`;
-    const updated = replaceAll ? original.split(find).join(replacement) : original.replace(find, replacement);
+    let styledReplacement = via === "desanitize" || via === "quotes+desanitize" ? desanitize(replacement) : replacement;
+    if (via === "quotes" || via === "quotes+desanitize")
+      styledReplacement = preserveQuoteStyle(actual, styledReplacement);
+    const updated = replaceAll ? original.split(actual).join(styledReplacement) : original.replace(actual, styledReplacement);
     if (updated === original)
       return `Edit error: replacement produced no change in ${target}.`;
     await ctx.execution.writeFile(ctx.handle, target, updated);
+    if (ctx.session) {
+      const readState = getReadState(ctx.session);
+      const absKey = `${ctx.handle.cwd}::${target}`;
+      const prior = readState?.get(absKey);
+      if (readState && prior) {
+        readState.set(absKey, { ...prior, contentHash: hashContent(updated), mtimeMs: Date.now() });
+      }
+    }
     return `Edited ${target}: replaced ${occurrences} occurrence${occurrences === 1 ? "" : "s"}.`;
   }
 };
@@ -441,7 +632,17 @@ var multiEdit = {
     try {
       current = await ctx.execution.readFile(ctx.handle, target);
     } catch {
-      return `multi_edit error: file not found: ${target}`;
+      const hint = await suggestionFor(ctx.execution, ctx.handle, target);
+      return `multi_edit error: file not found: ${target}.${hint}`;
+    }
+    if (ctx.behavior?.requireReadBeforeEdit && ctx.session) {
+      const readState = getReadState(ctx.session);
+      const absKey = `${ctx.handle.cwd}::${target}`;
+      const prior = readState?.get(absKey);
+      if (!prior)
+        return `multi_edit error: ${target} has not been read in this session. Call read_file first so the edits apply against the current contents.`;
+      if (prior.contentHash !== hashContent(current))
+        return `multi_edit error: ${target} has changed on disk since the last read. Re-read the file before editing.`;
     }
     let applied = 0;
     for (let i = 0; i < steps.length; i++) {
@@ -455,24 +656,77 @@ var multiEdit = {
         return `multi_edit error: edit #${i + 1} has empty old_string. Use write_file to fully replace a file.`;
       if (find === replacement)
         return `multi_edit error: edit #${i + 1} old_string and new_string are identical.`;
-      const occurrences = countExactMatches(current, find);
-      if (occurrences === 0)
+      const match = resolveOldString(current, find);
+      if (!match)
         return `multi_edit error: edit #${i + 1} old_string not found in ${target}.`;
+      const { actual, occurrences, via } = match;
       if (occurrences > 1 && !replaceAll)
         return `multi_edit error: edit #${i + 1} old_string appears ${occurrences} times. Pass replace_all=true on this edit or expand old_string for uniqueness.`;
-      current = replaceAll ? current.split(find).join(replacement) : current.replace(find, replacement);
+      let styledReplacement = via === "desanitize" || via === "quotes+desanitize" ? desanitize(replacement) : replacement;
+      if (via === "quotes" || via === "quotes+desanitize")
+        styledReplacement = preserveQuoteStyle(actual, styledReplacement);
+      current = replaceAll ? current.split(actual).join(styledReplacement) : current.replace(actual, styledReplacement);
       applied += occurrences;
     }
     await ctx.execution.writeFile(ctx.handle, target, current);
+    if (ctx.session) {
+      const readState = getReadState(ctx.session);
+      const absKey = `${ctx.handle.cwd}::${target}`;
+      const prior = readState?.get(absKey);
+      if (readState && prior) {
+        readState.set(absKey, { ...prior, contentHash: hashContent(current), mtimeMs: Date.now() });
+      }
+    }
     return `Edited ${target}: applied ${steps.length} edit${steps.length === 1 ? "" : "s"} (${applied} replacement${applied === 1 ? "" : "s"}).`;
   }
 };
 
 // src/tools/read-file.ts
+import { Buffer as Buffer2 } from "buffer";
+
+// src/tools/binary-read.ts
 import { Buffer } from "buffer";
+function imageMediaTypeFor(path) {
+  const dot = path.lastIndexOf(".");
+  if (dot === -1)
+    return void 0;
+  const ext = path.slice(dot + 1).toLowerCase();
+  switch (ext) {
+    case "png":
+      return "image/png";
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "gif":
+      return "image/gif";
+    case "webp":
+      return "image/webp";
+    default:
+      return void 0;
+  }
+}
+async function readFileAsBase64(execution, handle, path) {
+  if (execution.readFileBinary) {
+    const bytes = await execution.readFileBinary(handle, path);
+    const b642 = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
+    return { base64: b642, byteLength: bytes.byteLength };
+  }
+  const cmd = `base64 < ${shellQuote2(path)}`;
+  const result = await execution.exec(handle, cmd);
+  if (result.exitCode !== 0)
+    throw new Error(`base64 read failed: ${result.stderr || `exit ${result.exitCode}`}`);
+  const b64 = result.stdout.replace(/\s+/g, "");
+  return { base64: b64, byteLength: Math.floor(b64.length * 3 / 4) };
+}
+function shellQuote2(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+
+// src/tools/read-file.ts
 var DEFAULT_LINE_LIMIT = 2e3;
 var DEFAULT_BYTE_CAP = 65536;
 var BINARY_PROBE_BYTES = 8e3;
+var DEFAULT_IMAGE_BYTE_CAP = 5 * 1024 * 1024;
 var readFile = {
   spec: {
     name: "read_file",
@@ -489,19 +743,52 @@ var readFile = {
     }
   },
   async execute({ path, offset, limit, maxBytes }, ctx) {
+    const imgMedia = imageMediaTypeFor(path);
+    if (imgMedia) {
+      const sizeCap = maxBytes !== void 0 ? normalizeInteger(maxBytes, DEFAULT_IMAGE_BYTE_CAP) : DEFAULT_IMAGE_BYTE_CAP;
+      try {
+        const { base64, byteLength } = await readFileAsBase64(ctx.execution, ctx.handle, path);
+        if (sizeCap > 0 && byteLength > sizeCap) {
+          return `[image too large to inline: ${path}, ${byteLength} bytes (cap ${sizeCap}). Raise maxBytes, or use shell to inspect.]`;
+        }
+        const content = [
+          { type: "text", text: `Image: ${path} (${byteLength} bytes, ${imgMedia})` },
+          { type: "image", mediaType: imgMedia, data: base64 }
+        ];
+        return content;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const hint = await suggestionFor(ctx.execution, ctx.handle, path);
+        return `Image read failed: ${path} \u2014 ${msg}.${hint}`;
+      }
+    }
     let raw;
     try {
       raw = await ctx.execution.readFile(ctx.handle, path);
     } catch {
-      return `File not found: ${path}`;
+      const hint = await suggestionFor(ctx.execution, ctx.handle, path);
+      return `File not found: ${path}.${hint}`;
+    }
+    const totalBytes = Buffer2.byteLength(raw);
+    const dedupEnabled = ctx.behavior?.dedupReads !== false;
+    const readState = dedupEnabled ? getReadState(ctx.session) : void 0;
+    const absKey = `${ctx.handle.cwd}::${path}`;
+    const offsetForKey = normalizeInteger(offset, 1);
+    const limitForKey = normalizeInteger(limit, DEFAULT_LINE_LIMIT);
+    const maxBytesForKey = normalizeInteger(maxBytes, DEFAULT_BYTE_CAP);
+    const currentHash = readState ? hashContent(raw) : "";
+    if (readState) {
+      const prior = readState.get(absKey);
+      if (prior && prior.contentHash === currentHash && prior.offset === offsetForKey && prior.limit === limitForKey && prior.maxBytes === maxBytesForKey) {
+        return `File ${path} unchanged since the previous read in this session \u2014 the prior result is still current.`;
+      }
     }
-    const totalBytes = Buffer.byteLength(raw);
     if (looksBinary(raw)) {
       return `[binary file: ${path}, ${totalBytes} bytes; use shell with hexdump | xxd | od to inspect]`;
     }
-    const offsetN = normalizeInteger(offset, 1);
-    const limitN = normalizeInteger(limit, DEFAULT_LINE_LIMIT);
-    const maxBytesN = normalizeInteger(maxBytes, DEFAULT_BYTE_CAP);
+    const offsetN = offsetForKey;
+    const limitN = limitForKey;
+    const maxBytesN = maxBytesForKey;
     const lines = raw.split("\n");
     const totalLines = lines.length;
     const startIdx = Math.max(0, offsetN - 1);
@@ -512,7 +799,7 @@ var readFile = {
     if (maxBytesN > 0) {
       const truncatedSlice = [];
       for (const line of slice) {
-        const lineBytes = Buffer.byteLength(line) + 1;
+        const lineBytes = Buffer2.byteLength(line) + 1;
         if (bytesUsed + lineBytes > maxBytesN && truncatedSlice.length > 0) {
           bytesCut = true;
           break;
@@ -529,14 +816,14 @@ var readFile = {
     }
     let midLineCut = false;
     if (maxBytesN > 0 && slice.length > 0) {
-      const bodyBytes = Buffer.byteLength(slice.join("\n"));
+      const bodyBytes = Buffer2.byteLength(slice.join("\n"));
       if (bodyBytes > maxBytesN) {
         const lastIdx = slice.length - 1;
         const lastLine = slice[lastIdx];
-        const otherBytes = lastIdx > 0 ? Buffer.byteLength(slice.slice(0, lastIdx).join("\n")) + 1 : 0;
+        const otherBytes = lastIdx > 0 ? Buffer2.byteLength(slice.slice(0, lastIdx).join("\n")) + 1 : 0;
         const budgetForLast = Math.max(0, maxBytesN - otherBytes);
         let cut = Math.min(lastLine.length, budgetForLast);
-        while (cut > 0 && Buffer.byteLength(lastLine.slice(0, cut)) > budgetForLast)
+        while (cut > 0 && Buffer2.byteLength(lastLine.slice(0, cut)) > budgetForLast)
           cut--;
         slice[lastIdx] = lastLine.slice(0, cut);
         midLineCut = true;
@@ -546,6 +833,15 @@ var readFile = {
     const body = slice.join("\n");
     const linesReturned = slice.length;
     const lastLineRead = startIdx + linesReturned;
+    if (readState) {
+      readState.set(absKey, {
+        contentHash: currentHash,
+        offset: offsetN,
+        limit: limitN,
+        maxBytes: maxBytesN,
+        mtimeMs: Date.now()
+      });
+    }
     const linesTruncated = endIdx < totalLines || bytesCut;
     if (!linesTruncated && offsetN === 1)
       return body;
@@ -589,7 +885,38 @@ function looksBinary(text) {
 }
 
 // src/tools/shell.ts
-import { Buffer as Buffer2 } from "buffer";
+import { Buffer as Buffer3 } from "buffer";
+
+// src/tools/shell-semantics.ts
+var DEFAULT_SEMANTIC = (exitCode) => ({
+  isError: exitCode !== 0,
+  message: exitCode !== 0 ? `Command failed with exit code ${exitCode}` : void 0
+});
+var COMMAND_SEMANTICS = /* @__PURE__ */ new Map([
+  // grep / ripgrep: 0 = matches, 1 = no matches, ≥2 = error.
+  ["grep", (exit) => ({ isError: exit >= 2, message: exit === 1 ? "No matches found" : void 0 })],
+  ["rg", (exit) => ({ isError: exit >= 2, message: exit === 1 ? "No matches found" : void 0 })],
+  // diff: 0 = identical, 1 = differ, ≥2 = error.
+  ["diff", (exit) => ({ isError: exit >= 2, message: exit === 1 ? "Files differ" : void 0 })],
+  // find: 0 = ok, 1 = some dirs inaccessible (warning), ≥2 = error.
+  ["find", (exit) => ({ isError: exit >= 2, message: exit === 1 ? "Some directories were inaccessible" : void 0 })],
+  // test / [: 0 = condition true, 1 = condition false, ≥2 = error.
+  ["test", (exit) => ({ isError: exit >= 2, message: exit === 1 ? "Condition is false" : void 0 })],
+  ["[", (exit) => ({ isError: exit >= 2, message: exit === 1 ? "Condition is false" : void 0 })]
+]);
+function interpretShellResult(command, exitCode) {
+  const base = extractTrailingCommand(command);
+  const semantic = COMMAND_SEMANTICS.get(base) ?? DEFAULT_SEMANTIC;
+  return semantic(exitCode);
+}
+function extractTrailingCommand(command) {
+  const segments = command.split(/\|\||&&|[;|\n]/);
+  const last = segments[segments.length - 1]?.trim() ?? command;
+  const tokens = last.split(/\s+/).filter((t) => !/^[A-Z_]\w*=/i.test(t));
+  return tokens[0] ?? "";
+}
+
+// src/tools/shell.ts
 var DEFAULT_MAX_OUTPUT_BYTES = 8192;
 var shell = {
   spec: {
@@ -609,10 +936,19 @@ var shell = {
     const execOpts = {};
     if (typeof timeout === "number" && Number.isFinite(timeout) && timeout > 0)
       execOpts.timeout = Math.max(1, Math.ceil(timeout / 1e3));
-    const result = await ctx.execution.exec(ctx.handle, command, execOpts);
+    const cmd = command;
+    const result = await ctx.execution.exec(ctx.handle, cmd, execOpts);
     const cap = normalizeCap(maxOutputBytes);
+    const semantic = interpretShellResult(cmd, result.exitCode);
     if (result.exitCode === 0)
       return truncateTail(result.stdout || "(no output)", cap);
+    if (!semantic.isError) {
+      const body = (result.stdout || result.stderr || "").trim();
+      const tail = truncateTail(body, cap);
+      const footer = semantic.message ? `
+(${semantic.message})` : "";
+      return tail.length > 0 ? `${tail}${footer}` : semantic.message ?? "(no output)";
+    }
     const combined = `${result.stdout}
 ${result.stderr}`.trim();
     return `Exit code ${result.exitCode}
@@ -629,21 +965,21 @@ function normalizeCap(value) {
 function truncateTail(text, cap) {
   if (cap === 0)
     return text;
-  const totalBytes = Buffer2.byteLength(text);
+  const totalBytes = Buffer3.byteLength(text);
   if (totalBytes <= cap)
     return text;
   let bytes = 0;
   let charIdx = text.length;
   while (charIdx > 0) {
     const ch = text[charIdx - 1];
-    const chBytes = Buffer2.byteLength(ch);
+    const chBytes = Buffer3.byteLength(ch);
     if (bytes + chBytes > cap)
       break;
     bytes += chBytes;
     charIdx--;
   }
   const tail = text.slice(charIdx);
-  const droppedBytes = totalBytes - Buffer2.byteLength(tail);
+  const droppedBytes = totalBytes - Buffer3.byteLength(tail);
   return `\u2026(${droppedBytes} bytes truncated from head)\u2026
 ${tail}`;
 }
@@ -1101,6 +1437,43 @@ var IMAGE_OMITTED_MARKER = "[image omitted \u2014 model does not support vision]
 function turnsToMessages(turns) {
   return turns.filter((t) => t.role !== "system").map((t) => ({ role: t.role, content: t.content }));
 }
+var COMPACTION_STUB = "[\u2026elided by client-side tail compaction; ask the user or re-run the tool to retrieve.]";
+function applyTailCompaction(messages, threshold, keepTurns) {
+  if (messages.length === 0)
+    return messages;
+  let totalBytes = 0;
+  for (const msg of messages) {
+    for (const block of msg.content) {
+      if (block.type === "tool_result")
+        totalBytes += toolOutputByteLength(block.output);
+    }
+  }
+  if (totalBytes <= threshold)
+    return messages;
+  const keep = Math.max(0, keepTurns);
+  const cutoff = messages.length - keep;
+  if (cutoff <= 0)
+    return messages;
+  let changed = false;
+  const out = messages.slice();
+  for (let i = 0; i < cutoff; i++) {
+    const msg = out[i];
+    let msgChanged = false;
+    const newContent = msg.content.map((block) => {
+      if (block.type !== "tool_result")
+        return block;
+      const existingBytes = toolOutputByteLength(block.output);
+      if (existingBytes <= COMPACTION_STUB.length)
+        return block;
+      msgChanged = true;
+      changed = true;
+      return { ...block, output: COMPACTION_STUB };
+    });
+    if (msgChanged)
+      out[i] = { ...msg, content: newContent };
+  }
+  return changed ? out : messages;
+}
 function sanitizeStoredToolResults(provider, messages) {
   if (provider.meta.capabilities?.vision !== false)
     return messages;
@@ -1210,7 +1583,12 @@ async function executeTurn(ctx, turn) {
   const turnId = await ctx.generateTurnId();
   const canonicalMessages = turnsToMessages(ctx.turns);
   const wireMessages = rewriteMessagesToWire(canonicalMessages, ctx.aliasMaps);
-  const sanitizedMessages = sanitizeStoredToolResults(ctx.provider, wireMessages);
+  let sanitizedMessages = sanitizeStoredToolResults(ctx.provider, wireMessages);
+  if (ctx.compactStrategy === "tail") {
+    const threshold = typeof ctx.compactThreshold === "number" && ctx.compactThreshold > 0 ? ctx.compactThreshold : 131072;
+    const keep = typeof ctx.compactKeepTurns === "number" && ctx.compactKeepTurns >= 0 ? ctx.compactKeepTurns : 4;
+    sanitizedMessages = applyTailCompaction(sanitizedMessages, threshold, keep);
+  }
   const streamOptions = {
     model: ctx.model,
     system: ctx.system,
@@ -1337,6 +1715,17 @@ async function executeTurn(ctx, turn) {
     }
     return { ended: true, turnId, usage: result.usage };
   }
+  if (canonicalToolCalls.length === 0 && result.usage.finishReason === "pause") {
+    const continueMsg = ctx.provider.userMessage("Please continue.");
+    ctx.turns.push({
+      id: await ctx.generateTurnId(),
+      runId: ctx.runId,
+      role: continueMsg.role,
+      content: continueMsg.content,
+      createdAt: Date.now()
+    });
+    return { ended: false, turnId, usage: result.usage };
+  }
   const toolResults = ctx.toolExecution === "parallel" ? await executeToolsParallel(ctx, canonicalToolCalls, turnId) : await executeToolsSequential(ctx, canonicalToolCalls, turnId);
   const toolResultMsg = ctx.provider.toolResultsMessage(toolResults);
   ctx.turns.push({
@@ -1479,15 +1868,16 @@ async function executeSingleTool(ctx, call, turnId) {
     output = await toolDef.execute(effectiveInput, toolCtx);
   } catch (err) {
     const error = err instanceof Error ? err : new Error(String(err));
-    await ctx.hooks.callHook("tool:error", {
+    const errorCtx = {
       turnId,
       callId,
       name: call.name,
       displayName,
       input: effectiveInput,
       error
-    });
-    output = `Tool error: ${error.message}`;
+    };
+    await ctx.hooks.callHook("tool:error", errorCtx);
+    output = errorCtx.result ?? `Tool error: ${error.message}`;
     isError = true;
   }
   const transformCtx = {
@@ -1690,7 +2080,10 @@ function resolveBehavior(agentBehavior, runBehavior) {
     thinkingBudget: runBehavior?.thinkingBudget ?? agentBehavior?.thinkingBudget,
     schema: runBehavior?.schema ?? agentBehavior?.schema,
     cache: runBehavior?.cache ?? agentBehavior?.cache ?? true,
-    toolOutputBudget: runBehavior?.toolOutputBudget ?? agentBehavior?.toolOutputBudget
+    toolOutputBudget: runBehavior?.toolOutputBudget ?? agentBehavior?.toolOutputBudget,
+    compactStrategy: runBehavior?.compactStrategy ?? agentBehavior?.compactStrategy ?? "off",
+    compactThreshold: runBehavior?.compactThreshold ?? agentBehavior?.compactThreshold,
+    compactKeepTurns: runBehavior?.compactKeepTurns ?? agentBehavior?.compactKeepTurns
   };
 }
 function createAgent({ provider, name: agentName, system: agentSystem, tools: agentTools, toolAliases, behavior: agentBehavior, execution, mcpServers, session, skills: agentSkills, mcpConnector, eager }) {
@@ -1813,7 +2206,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
     }
     const thinking = options.thinking ?? "off";
     const model = options.model ?? provider.meta.defaultModel;
-    const { toolExecution, maxTurns, maxTokens, thinkingBudget, schema, cache, toolOutputBudget } = resolveBehavior(agentBehavior, options.behavior);
+    const { toolExecution, maxTurns, maxTokens, thinkingBudget, schema, cache, toolOutputBudget, compactStrategy, compactThreshold, compactKeepTurns } = resolveBehavior(agentBehavior, options.behavior);
     let system = options.system || agentSystem || "You are a helpful assistant.";
     if (skillsCatalog) {
       system = `${system}
@@ -1949,6 +2342,9 @@ ${skillsCatalog}`;
         schema,
         cache,
         toolOutputBudget,
+        compactStrategy,
+        compactThreshold,
+        compactKeepTurns,
         runStartMs
       });
       const finalStats = {
@@ -2393,7 +2789,7 @@ function createSpawnTool(options = {}) {
 var spawn = createSpawnTool();
 
 // src/tools/write-file.ts
-import { Buffer as Buffer3 } from "buffer";
+import { Buffer as Buffer4 } from "buffer";
 var writeFile = {
   spec: {
     name: "write_file",
@@ -2415,7 +2811,7 @@ var writeFile = {
       existing = await ctx.execution.readFile(ctx.handle, targetPath);
     } catch {
     }
-    const bytes = Buffer3.byteLength(targetContent);
+    const bytes = Buffer4.byteLength(targetContent);
     if (existing === targetContent)
       return `No change needed: ${targetPath} already at target state (${bytes} bytes).`;
     await ctx.execution.writeFile(ctx.handle, targetPath, targetContent);

package/dist/{chunk-2EQT4EHD.js → chunk-IUBBVF53.js}

@@ -176,6 +176,10 @@ function createProcessContext(config) {
     async readFile(handle, path) {
       return readFile(resolve(handle.cwd, path), "utf-8");
     },
+    async readFileBinary(handle, path) {
+      const buf = await readFile(resolve(handle.cwd, path));
+      return new Uint8Array(buf);
+    },
     async writeFile(handle, path, content) {
       const fullPath = resolve(handle.cwd, path);
       await mkdir(dirname(fullPath), { recursive: true });

package/dist/contexts.d.ts

@@ -1,6 +1,6 @@
-import { S as SpawnConfig, b as ExecutionContext } from './types-BpvTmawk.js';
-export { C as ContextCapabilities, a as ContextType, E as ExecResult, c as ExecutionHandle } from './types-BpvTmawk.js';
-export { S as SandboxProvider, c as createSandboxContext } from './sandbox-CW72eLDP.js';
+import { S as SpawnConfig, b as ExecutionContext } from './types-vA1a_ZX7.js';
+export { C as ContextCapabilities, a as ContextType, E as ExecResult, c as ExecutionHandle } from './types-vA1a_ZX7.js';
+export { S as SandboxProvider, c as createSandboxContext } from './sandbox-CLghrTLi.js';
 
 /**
  * Docker execution context.